tspace-mysql 1.9.0 → 1.9.1-beta.2

package/dist/lib/core/Model.js

@@ -48,6 +48,8 @@ const Cache_1 = require("./Cache");
 const JoinModel_1 = require("./JoinModel");
 const constants_1 = require("../constants");
 const Decorator_1 = require("./Decorator");
+const Join_1 = require("./Join");
+const Repository_1 = require("./Repository");
 let globalSettings = {
     softDelete: false,
     debug: false,
@@ -164,12 +166,475 @@ class Model extends AbstractModel_1.AbstractModel {
     static get instance() {
         return new this();
     }
+    /**
+     * The 'query' method is used to return instance
+     * @static
+     * @example
+     * const user = await User.query().where('id',1).findOne();
+     * console.log(user);
+     */
+    static query() {
+        return new this();
+    }
+    /**
+     *
+     * The 'find' method is used to retrieve a single record from a database table by its primary key.
+     *
+     * It allows you to retrieve a single record from a database table that meets the specified criteria.
+     * @type     {?object}  options
+     * @property {?object} options.select
+     * @property {?object} options.except
+     * @property {?object[]} options.orderBy
+     * @property {?string[]} options.groupBy
+     * @property {?string} options.having
+     * @property {?number} options.limit
+     * @property {?number} options.offset
+     * @property {?object} options.where
+     * @property {?string[]} options.whereRaw
+     * @property {?object} options.whereQuery
+     * @property {?{condition,callback}} options.when
+     * @property {?{localKey , referenceKey}[]} options.join
+     * @property {?{localKey , referenceKey}[]} options.rightJoin
+     * @property {?{localKey , referenceKey}[]} options.leftJoin
+     * @property {?string[]} options.relations
+     * @property {string[]} options.relationExists
+     * @property {?{condition,callback}} options.relationQuery
+     * @property {?boolean} options.debug
+     * @returns {promise<object>[]}
+     *
+     * @example
+     * import { User } from '../Models/User'
+     *
+     * const users = await User.find({
+     *       select : { id: true, name: true },
+     *       where : {
+     *           id: 1
+     *       }
+     *   })
+     *
+     */
+    static async find(primaryKey, options = {}) {
+        return await (0, Repository_1.Repository)(this).find(primaryKey, options);
+    }
+    /**
+     *
+     * The 'findOne' method is used to retrieve the get record that matches the query conditions.
+     *
+     * It allows you to retrieve a single record from a database table that meets the specified criteria.
+     * @type     {?object}  options
+     * @property {?object} options.select
+     * @property {?object} options.except
+     * @property {?object[]} options.orderBy
+     * @property {?string[]} options.groupBy
+     * @property {?string} options.having
+     * @property {?number} options.limit
+     * @property {?number} options.offset
+     * @property {?object} options.where
+     * @property {?string[]} options.whereRaw
+     * @property {?object} options.whereQuery
+     * @property {?{condition,callback}} options.when
+     * @property {?{localKey , referenceKey}[]} options.join
+     * @property {?{localKey , referenceKey}[]} options.rightJoin
+     * @property {?{localKey , referenceKey}[]} options.leftJoin
+     * @property {?string[]} options.relations
+     * @property {string[]} options.relationExists
+     * @property {?{condition,callback}} options.relationQuery
+     * @property {?boolean} options.debug
+     * @returns {promise<object>[]}
+     *
+     * @example
+     * import { User } from '../Models/User'
+     *
+     * const users = await User.findOne({
+     *       select : { id: true, name: true },
+     *       where : {
+     *           id: 1
+     *       }
+     *   })
+     *
+     */
+    static async findOne(options = {}) {
+        return await (0, Repository_1.Repository)(this).findOne(options);
+    }
+    /**
+     *
+     * The 'findMany' method is used to retrieve the get record that matches the query conditions.
+     *
+     * It allows you to retrieve a single record from a database table that meets the specified criteria.
+     * @type     {?object}  options
+     * @property {?object} options.select
+     * @property {?object} options.except
+     * @property {?object[]} options.orderBy
+     * @property {?string[]} options.groupBy
+     * @property {?string} options.having
+     * @property {?number} options.limit
+     * @property {?number} options.offset
+     * @property {?object} options.where
+     * @property {?string[]} options.whereRaw
+     * @property {?object} options.whereQuery
+     * @property {?{condition,callback}} options.when
+     * @property {?{localKey , referenceKey}[]} options.join
+     * @property {?{localKey , referenceKey}[]} options.rightJoin
+     * @property {?{localKey , referenceKey}[]} options.leftJoin
+     * @property {?string[]} options.relations
+     * @property {string[]} options.relationExists
+     * @property {?{condition,callback}} options.relationQuery
+     * @property {?boolean} options.debug
+     * @returns {promise<object>[]}
+     *
+     * @example
+     * import { User } from '../Models/User'
+     *
+     * const users = await User.findMany({
+     *       select : { id: true, name: true },
+     *       where : {
+     *           id: 1
+     *       }
+     *   })
+     *
+     */
+    static async findMany(options = {}) {
+        return await (0, Repository_1.Repository)(this).findMany(options);
+    }
+    /**
+     *
+     * The 'paginate' method is used to perform pagination on a set of database query results obtained through the Query Builder.
+     *
+     * It allows you to split a large set of query results into smaller, more manageable pages,
+     * making it easier to display data in a web application and improve user experience.
+     * @type     {?object}  options
+     * @property {?object} options.select
+     * @property {?object} options.except
+     * @property {?object[]} options.orderBy
+     * @property {?string[]} options.groupBy
+     * @property {?string} options.having
+     * @property {?number} options.limit
+     * @property {?number} options.offset
+     * @property {?object} options.where
+     * @property {?string[]} options.whereRaw
+     * @property {?object} options.whereQuery
+     * @property {?{condition,callback}} options.when
+     * @property {?{localKey , referenceKey}[]} options.join
+     * @property {?{localKey , referenceKey}[]} options.rightJoin
+     * @property {?{localKey , referenceKey}[]} options.leftJoin
+     * @property {?string[]} options.relations
+     * @property {string[]} options.relationExists
+     * @property {?{condition,callback}} options.relationQuery
+     * @property {?boolean} options.debug
+     * @property {?number} options.page
+     * @returns {promise<{ meta , data[]}>}
+     *
+     * @example
+     * import { User } from '../Models/User'
+     *
+     *  const users = await User.paginate({
+     *       limit:15,
+     *       page: 1,
+     *       select : { id: true, name: true },
+     *       where : {
+     *           id: 1
+     *       }
+     *   })
+     */
+    static async paginate(options = {}) {
+        return await (0, Repository_1.Repository)(this).paginate(options);
+    }
+    /**
+     * The 'exists' method is used to determine if any records exist in the database table that match the query conditions.
+     *
+     * It returns a boolean value indicating whether there are any matching records.
+     * @type     {?object}  options
+     * @property {?object} options.select
+     * @property {?object} options.except
+     * @property {?object[]} options.orderBy
+     * @property {?string[]} options.groupBy
+     * @property {?string} options.having
+     * @property {?number} options.limit
+     * @property {?number} options.offset
+     * @property {?object} options.where
+     * @property {?string[]} options.whereRaw
+     * @property {?object} options.whereQuery
+     * @property {?{condition,callback}} options.when
+     * @property {?{localKey , referenceKey}[]} options.join
+     * @property {?{localKey , referenceKey}[]} options.rightJoin
+     * @property {?{localKey , referenceKey}[]} options.leftJoin
+     * @property {?boolean} options.debug
+     * @property {?number} options.page
+     *
+     * @example
+     *  import { User } from '../Models/User'
+     *
+     *  const users = await User.exists({
+     *       where : {
+     *           id: 1
+     *       }
+     *   })
+     *
+     */
+    static async exists(options) {
+        return await (0, Repository_1.Repository)(this).exists(options);
+    }
+    /**
+     * The 'toQuery' method is used to retrieve the raw SQL query that would be executed by a query builder instance without actually executing it.
+     *
+     * This method is particularly useful for debugging and understanding the SQL queries generated by your application.
+     * @type     {?object}  options
+     * @property {?object} options.select
+     * @property {?object} options.except
+     * @property {?object[]} options.orderBy
+     * @property {?string[]} options.groupBy
+     * @property {?string} options.having
+     * @property {?number} options.limit
+     * @property {?number} options.offset
+     * @property {?object} options.where
+     * @property {?string[]} options.whereRaw
+     * @property {?object} options.whereQuery
+     * @property {?{condition,callback}} options.when
+     * @property {?{localKey , referenceKey}[]} options.join
+     * @property {?{localKey , referenceKey}[]} options.rightJoin
+     * @property {?{localKey , referenceKey}[]} options.leftJoin
+     * @property {?boolean} options.debug
+     * @property {?number} options.page
+     *
+     * @example
+     *  import { User } from '../Models/User'
+     *
+     *  const users = await User.exists({
+     *       where : {
+     *           id: 1
+     *       }
+     *   })
+     *
+     */
+    static toQuery(options) {
+        return (0, Repository_1.Repository)(this).toString(options);
+    }
+    /**
+     * The 'create' method is used to insert a new record into a database table associated.
+     *
+     * It simplifies the process of creating and inserting records.
+     * @type     {object}  options
+     * @property {object} options.data
+     * @property {?boolean} options.debug
+     * @property {?transaction} options.transaction
+     * @return {promise<T.Result<M>>}
+     */
+    static async create(options) {
+        return (0, Repository_1.Repository)(this).create(options);
+    }
+    /**
+     * The 'createMany' method is used to insert a new records into a database table associated.
+     *
+     * It simplifies the process of creating and inserting records with an array.
+     * @type     {object}  options
+     * @property {object[]} options.data
+     * @property {?boolean} options.debug
+     * @property {?transaction} options.transaction
+     * @return {promise<TS[]>}
+     */
+    static async createMany(options) {
+        return (0, Repository_1.Repository)(this).createMany(options);
+    }
+    /**
+     *
+     * The 'createOrUpdate' method allows you to update an existing record in a database table if it exists or create a new record if it does not exist.
+     *
+     * This method is particularly useful when you want to update a record based on certain conditions and,
+     * if the record matching those conditions doesn't exist, create a new one with the provided data.
+     * @type     {object}  options
+     * @property {object} options.data
+     * @property {object} options.where
+     * @property {?boolean} options.debug
+     * @return {promise<NR extends true ? undefined : T.Result<M>[]>}
+     */
+    static async createOrUpdate(options) {
+        //@ts-ignore
+        return (0, Repository_1.Repository)(this).createOrUpdate(options);
+    }
+    /**
+     * The 'createNotExists' method to insert data into a database table while ignoring any duplicate key constraint violations.
+     *
+     * This method is particularly useful when you want to insert records into a table and ensure that duplicates are not inserted,
+     * but without raising an error or exception if duplicates are encountered.
+     *
+     * @type     {object}  options
+     * @property {object} options.data
+     * @property {object} options.where
+     * @property {?boolean} options.debug
+     * @property {?transaction} options.transaction
+     * @return {promise<T | null>}
+     */
+    static async createNotExists(options) {
+        return (0, Repository_1.Repository)(this).createNotExists(options);
+    }
+    /**
+     *
+     * The 'createOrSelect' method to insert data into a database table while select any duplicate key constraint violations.
+     *
+     * This method is particularly useful when you want to insert records into a table and ensure that duplicates are not inserted,
+     * but if exists should be returns a result.
+     * @type     {object}  options
+     * @property {object} options.data
+     * @property {object} options.where
+     * @property {?boolean} options.debug
+     * @return {promise<T.Result<M>>}
+     */
+    static async createOrSelect(options) {
+        return (0, Repository_1.Repository)(this).createOrSelect(options);
+    }
+    /**
+     * The 'update' method is used to update existing records in a database table that are associated.
+     *
+     * It simplifies the process of updating records by allowing you to specify the values to be updated using a single call.
+     *
+     * It allows you to remove one record that match certain criteria.
+     * @type     {object} options
+     * @property {object} options.data
+     * @property {object} options.where
+     * @property {?boolean} options.debug
+     * @property {?transaction} options.transaction
+     * @return {promise< NR extends true ? undefined : T.Result<M> | null>}
+     */
+    static async update(options) {
+        return (0, Repository_1.Repository)(this).update(options);
+    }
+    /**
+     * The 'updateMany' method is used to update existing records in a database table that are associated.
+     *
+     * It simplifies the process of updating records by allowing you to specify the values to be updated using a single call.
+     *
+     * It allows you to remove more records that match certain criteria.
+     * @type     {object} options
+     * @property {object} options.data
+     * @property {object} options.where
+     * @property {?boolean} options.debug
+     * @property {?transaction} options.transaction
+     * @return {promise<T.Result<M>[]>}
+     */
+    static async updateMany(options) {
+        return (0, Repository_1.Repository)(this).updateMany(options);
+    }
     /**
      * The 'cache' method is used get the functions from the Cache
-     * @returns {TCache} cache
+     * @returns {TCacheModel} cache
      */
     static get cache() {
-        return Cache_1.Cache;
+        const getCacheKey = (key) => {
+            const db = new this().database();
+            const table = new this().getTableName();
+            return `${db}:${table}:${key}`;
+        };
+        return {
+            provider: () => Cache_1.Cache.provider(),
+            driver: (driver) => Cache_1.Cache.driver(driver),
+            all: async () => {
+                return await Cache_1.Cache.all();
+            },
+            clear: async () => {
+                return await Cache_1.Cache.clear();
+            },
+            get: async (key, options) => {
+                const cacheKey = options?.namespace ? getCacheKey(key) : key;
+                return await Cache_1.Cache.get(cacheKey);
+            },
+            exists: async (key, options) => {
+                const cacheKey = options?.namespace ? getCacheKey(key) : key;
+                return await Cache_1.Cache.exists(cacheKey);
+            },
+            set: async (key, value, ms, options) => {
+                const cacheKey = options?.namespace ? getCacheKey(key) : key;
+                return await Cache_1.Cache.set(cacheKey, value, ms);
+            },
+            delete: async (key, options) => {
+                const cacheKey = options?.namespace ? getCacheKey(key) : key;
+                return await Cache_1.Cache.delete(cacheKey);
+            },
+        };
+    }
+    /**
+     * The 'lockTable' method is used table lock and execute the callback within the lock scope.
+     *
+     * The lock is automatically released after the callback completes,
+     * regardless of whether it resolves or throws an error.
+     *
+     * READ:
+     * - Other sessions can read.
+     * - Other sessions must wait before writing.
+     * - SELECT: allowed
+     * - INSERT: waits
+     * - UPDATE: waits
+     * - DELETE: waits
+     *
+     * WRITE:
+     * - Other sessions must wait before reading or writing.
+     * - SELECT: waits
+     * - INSERT: waits
+     * - UPDATE: waits
+     * - DELETE: waits
+     *
+     * The lock is released automatically after the callback completes.
+     *
+     * @Note
+     * This approach is not recommended in clustered or load-balance environments,
+     * because locks are session-bound and requests may be routed to different database connections.
+     *
+     * @template T
+     * @param {'READ'|'WRITE'} mode Lock mode.
+     * @param {(query: this) => Promise<T>} handler Function executed while the table is locked.
+     * @returns {Promise<T>} The value returned by the callback.
+     *
+     * @example
+     * await User.lockTable('READ', async (query) => {
+     *   query.get();
+     *   return
+     * });
+     *
+     * @example
+     * await User.lockTable('WRITE', async (query) => {
+     *   // Avoid creating a new query instance inside the lock.
+     *   // The new instance uses a different connection/session and
+     *   // may wait for the current table lock to be released.
+     *
+     *   new User().insert({
+     *     first_name: 'John',
+     *     last_name: 'Doe'
+     *   }).save();
+     *
+     *   // Use the locked query instance instead.
+     *   await query.insert({
+     *     first_name: 'John',
+     *     last_name: 'Doe'
+     *   }).save();
+     * });
+     */
+    static async lockTable(mode, handler) {
+        const trx = await DB_1.DB.beginTransaction();
+        try {
+            await trx.startTransaction();
+            const model = new this()
+                .bind(trx);
+            const sqlLockTable = model
+                ._queryBuilder()
+                .lockTable(mode);
+            await model.rawQuery(sqlLockTable);
+            const results = await handler(model);
+            const sqlUnlockTable = model
+                ._queryBuilder()
+                .unlockTable();
+            if (sqlUnlockTable != null) {
+                await model
+                    .rawQuery(sqlUnlockTable);
+            }
+            await trx.commit();
+            return results;
+        }
+        catch (err) {
+            await trx.rollback();
+            throw err;
+        }
+        finally {
+            await trx.end();
+        }
     }
     /**
      *  The 'boot' method is a special method that you can define within a model.
@@ -219,18 +684,12 @@ class Model extends AbstractModel_1.AbstractModel {
                 this.$state.set("SELECT", [...this.$state.get("SELECT"), ...select]);
             }
             if (except.length) {
-                this.$state.set("EXCEPTS", [
-                    ...this.$state.get("EXCEPTS"),
-                    ...except
-                ]);
+                this.$state.set("EXCEPTS", [...this.$state.get("EXCEPTS"), ...except]);
             }
             if (where.length) {
                 this.$state.set("WHERE", [
                     ...this.$state.get("WHERE"),
-                    [
-                        this.$state.get("WHERE").length ? `${this.$constants("AND")}` : "",
-                        ...where,
-                    ].join(" "),
+                    ...where
                 ]);
             }
             if (groupBy.length) {
@@ -370,31 +829,31 @@ class Model extends AbstractModel_1.AbstractModel {
         return this;
     }
     /**
-    * The "useTransform " method is used to define value transformers for model columns..
-    *
-    * Each transformer defines how a value is converted:
-    * - `to`   : before persisting to the database
-    * - `from` : after retrieving from the database
-    *
-    * Transformers can be synchronous or asynchronous.
-    *
-    * @param {object} transforms
-    * @example
-    * import { Blueprint } from 'tspace-mysql';
-    * class User extends Model {
-    *     boot() {
-    *        this.useTransform({
-    *            name : {
-    *              to   : async (v) => `${v}-> transform@before`,
-    *              from : async (v) => `${v}-> transform@after`,
-    *            },
-    *         })
-    *     }
-    * }
-    * @returns {this} this
-    */
+     * The "useTransform " method is used to define value transformers for model columns..
+     *
+     * Each transformer defines how a value is converted:
+     * - `to`   : before persisting to the database
+     * - `from` : after retrieving from the database
+     *
+     * Transformers can be synchronous or asynchronous.
+     *
+     * @param {object} transforms
+     * @example
+     * import { Blueprint } from 'tspace-mysql';
+     * class User extends Model {
+     *     boot() {
+     *        this.useTransform({
+     *            name : {
+     *              to   : async (v) => `${v}-> transform@before`,
+     *              from : async (v) => `${v}-> transform@after`,
+     *            },
+     *         })
+     *     }
+     * }
+     * @returns {this} this
+     */
     useTransform(transforms) {
-        this.$state.set('TRANSFORMS', transforms);
+        this.$state.set("TRANSFORMS", transforms);
         return this;
     }
     /**
@@ -453,11 +912,11 @@ class Model extends AbstractModel_1.AbstractModel {
      */
     usePattern(pattern) {
         const allowPattern = [
-            this.$constants("PATTERN").snakeCase,
+            this.$constants("PATTERN").snake_case,
             this.$constants("PATTERN").camelCase,
         ];
         if (!allowPattern.includes(pattern)) {
-            throw this._assertError(`The 'tspace-mysql' support only pattern '${this.$constants("PATTERN").snakeCase}', 
+            throw this._assertError(`The 'tspace-mysql' support only pattern '${this.$constants("PATTERN").snake_case}', 
                 '${this.$constants("PATTERN").camelCase}'`);
         }
         this.$state.set("PATTERN", pattern);
@@ -490,7 +949,7 @@ class Model extends AbstractModel_1.AbstractModel {
      * }
      */
     useSnakeCase() {
-        this.$state.set("PATTERN", this.$constants("PATTERN").snakeCase);
+        this.$state.set("PATTERN", this.$constants("PATTERN").snake_case);
         this._makeTableName();
         return this;
     }
@@ -746,7 +1205,7 @@ class Model extends AbstractModel_1.AbstractModel {
      * this
      *   .useLifecycle("beforeInsert", fnA)
      *   .useLifecycle("afterInsert", fnB);
-    */
+     */
     useLifecycle(type, funcs) {
         const MAP = {
             beforeInsert: "LIFECYCLE_BEFORE_INSERTS",
@@ -886,7 +1345,9 @@ class Model extends AbstractModel_1.AbstractModel {
                     return except !== column;
                 });
             });
-            removeExcepts.push(hasDot ? removeExcept.map((r) => `\`${tableName}\`.${r}`) : removeExcept);
+            removeExcepts.push(hasDot
+                ? removeExcept.map((r) => `\`${tableName}\`.${r}`)
+                : removeExcept);
         }
         return removeExcepts.flat();
     }
@@ -898,13 +1359,11 @@ class Model extends AbstractModel_1.AbstractModel {
      */
     buildMethodRelation(name, callback) {
         this.relations(name);
-        const relation = this.$state
-            .get("RELATIONS")
-            .find((v) => v.name === name);
+        const relation = this.$state.get("RELATIONS").find((v) => v.name === name);
         if (relation == null) {
             throw this._assertError(`This Relation '${String(name)}' not be register in Model '${this.constructor?.name}'.`);
         }
-        const relationHasExists = Object.values(this.$constants("RELATIONSHIP"))?.includes(relation.relation);
+        const relationHasExists = Object.values(this.$constants("RELATIONSHIP"))?.includes(relation.relation ?? "");
         if (!relationHasExists) {
             throw this._assertError(`Unknown relationship in '${this.$constants("RELATIONSHIP")}'.`);
         }
@@ -928,7 +1387,7 @@ class Model extends AbstractModel_1.AbstractModel {
         this.$state.set("AUDIT", userId);
         return this;
     }
-    meta(meta) {
+    metaTag(meta) {
         this.$state.set("META", meta);
         return this;
     }
@@ -951,12 +1410,19 @@ class Model extends AbstractModel_1.AbstractModel {
      * @param {Object}  object
      * @property {string} key key of cache
      * @property {number} expires ms
+     * @property {boolean} namespace whether to use namespace for cache key, default is false, namespace is `${database}:${table}:${key}`
      * @returns {this} this
      */
-    cache({ key, expires }) {
+    cache({ key, expires, namespace }) {
+        const getCacheKey = (key) => {
+            const db = this.database();
+            const table = this.getTableName();
+            return `${db}:${table}:${key}`;
+        };
+        const cacheKey = namespace ? getCacheKey(key) : key;
         this.$state.set("CACHE", {
-            key,
-            expires,
+            key: cacheKey,
+            expires
         });
         return this;
     }
@@ -997,6 +1463,12 @@ class Model extends AbstractModel_1.AbstractModel {
         this.$state.set("SELECT", select);
         return this;
     }
+    /**
+     *
+     * @override
+     * @param {string[]} ...columns
+     * @returns {this} this
+     */
     addSelect(...columns) {
         let select = columns.map((c) => {
             const column = String(c);
@@ -1172,11 +1644,11 @@ class Model extends AbstractModel_1.AbstractModel {
      * @param {string} column
      * @returns {string} return table.column
      */
-    bindColumn(column, pattern = true) {
+    bindColumn(column, opts = { pattern: true }) {
         if (!/\./.test(column)) {
             if (column === "*")
                 return "*";
-            const c = pattern ? this._valuePattern(column) : column;
+            const c = opts.pattern ? this._valuePattern(column) : column;
             const alias = this.$state.get("ALIAS");
             return [
                 alias == null || alias === ""
@@ -1187,7 +1659,7 @@ class Model extends AbstractModel_1.AbstractModel {
             ].join("");
         }
         let [table, c] = column.split(".");
-        c = pattern ? this._valuePattern(c) : c;
+        c = opts.pattern ? this._valuePattern(c) : c;
         if (c === "*") {
             return `\`${table.replace(/`/g, "")}\`.*`;
         }
@@ -1346,8 +1818,6 @@ class Model extends AbstractModel_1.AbstractModel {
         newInstance.$state.set("SAVE", null);
         newInstance.$state.set("DEBUG", false);
         newInstance.$state.set("LOGGER", false);
-        newInstance.$state.set("AUDIT", null);
-        newInstance.$state.set("AUDIT_METADATA", null);
         newInstance.$state.set("LIFECYCLE_BEFORE_INSERTS", []);
         newInstance.$state.set("LIFECYCLE_BEFORE_UPDATES", []);
         newInstance.$state.set("LIFECYCLE_BEFORE_REMOVES", []);
@@ -1389,7 +1859,6 @@ class Model extends AbstractModel_1.AbstractModel {
      */
     async _queryStatement(sql, { retry = false } = {}) {
         try {
-            sql = this._queryBuilder({ onFormat: true }).format([sql]);
             const getResults = async (sql) => {
                 if (this.$state.get("DEBUG")) {
                     const startTime = +new Date();
@@ -1423,7 +1892,6 @@ class Model extends AbstractModel_1.AbstractModel {
                 throw error;
             const retryCount = Number(this.$state.get("RETRY"));
             await this._checkSchemaOrNextError(error, retryCount, error);
-            this.$state.set("RETRY", retryCount + 1);
             return await this._queryStatement(sql, { retry: true });
         }
     }
@@ -1436,7 +1904,6 @@ class Model extends AbstractModel_1.AbstractModel {
      */
     async _actionStatement(sql, { retry = false } = {}) {
         try {
-            sql = this._queryBuilder({ onFormat: true }).format([sql]);
             const getResults = async (sql) => {
                 if (this.$state.get("DEBUG")) {
                     const startTime = +new Date();
@@ -1470,7 +1937,6 @@ class Model extends AbstractModel_1.AbstractModel {
             if (this.$state.get("JOIN")?.length)
                 throw error;
             await this._checkSchemaOrNextError(error, retryCount, error);
-            this.$state.set("RETRY", retryCount + 1);
             return await this._actionStatement(sql, { retry: true });
         }
     }
@@ -1917,6 +2383,55 @@ class Model extends AbstractModel_1.AbstractModel {
         this.$relation.callback(String(nameRelation), callback);
         return this;
     }
+    /**
+    *
+    * The 'withQueryExists' 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
+    * @param {object} options pivot the query
+    * @example
+    *   import { Model } from 'tspace-mysql'
+    *   class User extends Model {
+    *       constructor(){
+    *           super()
+    *           this.hasMany({ name : 'posts' , model : Post })
+    *       }
+    *   }
+    *
+    *   class Post extends Model {
+    *       constructor(){
+    *           super()
+    *           this.hasMany({ name : 'comments' , model : Comment })
+    *           this.belongsTo({ name : 'user' , model : User })
+    *       }
+    *   }
+    *
+    *   class Comment extends Model {
+    *       constructor(){
+    *           super()
+    *           this.hasMany({ name : 'users' , model : User })
+    *           this.belongsTo({ name : 'post' , model : Post })
+    *       }
+    *   }
+    *
+    *   await new User().with('posts')
+    *   .withQueryExists('posts', (query : Post) => {
+    *       return query.with('comments','user')
+    *       .withQuery('comments', (query : Comment) => {
+    *           return query.with('user','post')
+    *       })
+    *       .withQueryExists('user', (query : User) => {
+    *           return query.with('posts').withQueryExists('posts',(query : Post)=> {
+    *               return query.with('comments','user')
+    *               // relation n, n, ...n
+    *           })
+    *       })
+    *   })
+    *  .findMany()
+    * @returns {this} this
+    */
     withQueryExists(nameRelation, callback, options = { pivot: false }) {
         this.withExists(nameRelation);
         if (options.pivot) {
@@ -2041,6 +2556,36 @@ class Model extends AbstractModel_1.AbstractModel {
         const instance = this.$relation.returnCallback(String(name));
         return instance == null ? null : instance;
     }
+    /**
+     * The 'ofMany' method is used to transform a many relationship,
+     * into a single related model by selecting one record using an aggregate
+     * function such as MAX or MIN on the specified column.
+     *
+     * @note
+     * This method is not supported on `belongsToMany` relationships.
+     *
+     * @param {string} column The column used for aggregation (e.g. `"id"`, `"created_at"`).
+     * @param {"MAX" | "MIN"} aggregate The aggregate function used to select the record.
+     * @param {((query: Model) => void) | undefined} callback A callback used to apply additional constraints to the aggregate query.
+     *
+     * Only filtering methods are supported. Methods that modify the result set,
+     * such as `select` `orderBy`, `groupBy`, `limit`, `offset`, `union`, and `having`, are not supported.
+     * @returns this
+    */
+    ofMany(column, aggregate, callback) {
+        const cb = callback == null
+            ? null
+            : callback(new Model().copyModel(this));
+        if (cb instanceof Promise) {
+            throw new Error("'ofMany' does not support Promises");
+        }
+        this.$state.set('OF_MANY', {
+            column: this.bindColumn(String(column)),
+            aggregate,
+            query: cb
+        });
+        return this;
+    }
     /**
      * The 'hasOne' relationship defines a one-to-one relationship between two database tables.
      *
@@ -2189,6 +2734,70 @@ class Model extends AbstractModel_1.AbstractModel {
         });
         return this;
     }
+    /**
+     * The 'createRelation' method is useful for Creates a relation accessor for a model.
+     *
+     * This method defines how a model relates to another model
+     * (hasOne, hasMany, belongsTo, belongsToMany) and returns
+     * a function that can be used to modify the relation query.
+     *
+     * Example:
+     * ```ts
+     * public posts = this.createRelation(Post, {
+     *   type: 'hasMany',
+     *   foreignKey: 'user_id',
+     * });
+     *
+     * user.posts(q => q.where('id', 1));
+     * ```
+     *
+     * @template M - Target model type
+     * @template K - Optional relation name type
+     *
+     * @param model - The related model constructor
+     * @param options - Relation configuration options
+     * @param options.type - Type of relation (hasOne, hasMany, belongsTo, belongsToMany)
+     * @param options.name - Optional relation name (when applicable)
+     * @param options.as - Alias for relation
+     * @param options.localKey - Local key for the relation
+     * @param options.foreignKey - Foreign key for the relation
+     * @param options.freezeTable - Override pivot/table name
+     * @param options.pivot - Pivot table name (for many-to-many)
+     * @param options.oldVersion - Enable legacy relation behavior
+     *
+     * @returns A function that accepts a query modifier and returns the relation result
+     */
+    createRelation(model, options) {
+        return (modifier) => {
+            const opts = {
+                name: options.name,
+                as: options.as,
+                localKey: options.localKey,
+                foreignKey: options.foreignKey,
+                freezeTable: options.freezeTable
+            };
+            switch (options.type) {
+                case 'hasOne': {
+                    return this.hasOneBuilder({ model, ...opts }, modifier);
+                }
+                case 'hasMany': {
+                    return this.hasManyBuilder({ model, ...opts }, modifier);
+                }
+                case 'belongsTo': {
+                    return this.belongsToBuilder({ model, ...opts }, modifier);
+                }
+                case 'belongsToMany': {
+                    return this.belongsToManyBuilder({
+                        model,
+                        ...opts,
+                        pivot: options.pivot,
+                        oldVersion: options.oldVersion,
+                        modelPivot: options.modelPivot
+                    }, modifier);
+                }
+            }
+        };
+    }
     /**
      * The 'hasOneBuilder' method is useful for creating 'hasOne' relationship to function
      *
@@ -2325,11 +2934,9 @@ class Model extends AbstractModel_1.AbstractModel {
         const query = this.$state.get("TIMESTAMP")
             ? `${deletedAt} = NULL , ${updatedAt} = '${this.$utils.timestamp()}'`
             : `${deletedAt} = NULL`;
-        this.$state.set("UPDATE", [
-            `${query}`
-        ]);
+        this.$state.set("UPDATE", [`${query}`]);
         this.$state.set("SAVE", "UPDATE");
-        return (await this.save());
+        return (await this.bind(this.$pool.get()).save());
     }
     /**
      *
@@ -2349,7 +2956,7 @@ class Model extends AbstractModel_1.AbstractModel {
     /**
      * @override
      * @param {string | K} column if arguments is object
-     * @param {string?} operator ['=', '<', '>' ,'!=', '!<', '!>' ,'LIKE']
+     * @param {string?} operator "=" | "<" | ">" | "!=" | "<>" | "<=" | ">=" | "LIKE" | "like"
      * @param {any?} value
      * @returns {this} this
      */
@@ -2358,9 +2965,6 @@ class Model extends AbstractModel_1.AbstractModel {
             return this.whereObject(column);
         }
         [value, operator] = this.$utils.valueAndOperator(value, operator, arguments.length === 2);
-        value = this.$utils.transfromDateToDateString(value);
-        value = this.$utils.escape(value);
-        value = this.$utils.transfromBooleanToNumber(value);
         const blueprint = this._getBlueprintByColumn(String(column));
         if (blueprint?.isVirtual) {
             const sql = blueprint.sql?.where;
@@ -2371,7 +2975,7 @@ class Model extends AbstractModel_1.AbstractModel {
                 if (Array.isArray(value)) {
                     const values = value
                         ? `${value
-                            .map((value) => this.$utils.transfromValueHasRaw(this.$utils.escape(value)))
+                            .map((value) => this.$utils.formatQueryValue(value))
                             .join(",")}`
                         : this.$constants(this.$constants("NULL"));
                     return this.whereRaw(`${sql} ${this.$constants("IN")} (${values})`);
@@ -2385,32 +2989,19 @@ class Model extends AbstractModel_1.AbstractModel {
         if (Array.isArray(value)) {
             return this.whereIn(column, value);
         }
-        const wheres = this.$state.get("WHERE");
+        const formatedValue = this.$utils.formatQueryValue(value);
         this.$state.set("WHERE", [
-            ...wheres,
-            [
-                wheres.length ? `${this.$constants("AND")}` : "",
-                `${this.bindColumn(String(column))}`,
-                `${operator}`,
-                `${this.$utils.transfromValueHasRaw(value)}`,
-            ]
-                .join(" ")
-                .replace(/^\s+/, "")
+            ...this.$state.get("WHERE"),
+            {
+                column: this.bindColumn(String(column)),
+                operator: operator,
+                value: formatedValue
+            }
         ]);
         return this;
     }
-    /**
-     * @override
-     * @param {string} column
-     * @param {string?} operator ['=', '<', '>' ,'!=', '!<', '!>' ,'LIKE']
-     * @param {any?} value
-     * @returns {this}
-     */
     orWhere(column, operator, value) {
         [value, operator] = this.$utils.valueAndOperator(value, operator, arguments.length === 2);
-        value = this.$utils.escape(value);
-        value = this.$utils.transfromBooleanToNumber(value);
-        value = this.$utils.transfromDateToDateString(value);
         const blueprint = this._getBlueprintByColumn(String(column));
         if (blueprint?.isVirtual) {
             const sql = blueprint.sql?.where;
@@ -2421,7 +3012,7 @@ class Model extends AbstractModel_1.AbstractModel {
                 if (Array.isArray(value)) {
                     const values = value
                         ? `${value
-                            .map((value) => this.$utils.transfromValueHasRaw(this.$utils.escape(value)))
+                            .map((value) => this.$utils.formatQueryValue(value))
                             .join(",")}`
                         : this.$constants(this.$constants("NULL"));
                     return this.orWhereRaw(`${sql} ${this.$constants("IN")} (${values})`);
@@ -2435,17 +3026,15 @@ class Model extends AbstractModel_1.AbstractModel {
         if (Array.isArray(value)) {
             return this.orWhereIn(column, value);
         }
-        const wheres = this.$state.get("WHERE");
+        const formatedValue = this.$utils.formatQueryValue(value);
         this.$state.set("WHERE", [
-            ...wheres,
-            [
-                wheres.length ? `${this.$constants("OR")}` : "",
-                `${this.bindColumn(String(column))}`,
-                `${operator}`,
-                `${this.$utils.transfromValueHasRaw(value)}`,
-            ]
-                .join(" ")
-                .replace(/^\s+/, ""),
+            ...this.$state.get("WHERE"),
+            {
+                column: this.bindColumn(String(column)),
+                operator: operator,
+                value: formatedValue,
+                condition: 'OR'
+            }
         ]);
         return this;
     }
@@ -2456,17 +3045,13 @@ class Model extends AbstractModel_1.AbstractModel {
      * @returns {this}
      */
     whereDay(column, day) {
-        const wheres = this.$state.get("WHERE");
         this.$state.set("WHERE", [
-            ...wheres,
-            [
-                wheres.length ? `${this.$constants("AND")}` : "",
-                `DAY(${this.bindColumn(String(column))})`,
-                `=`,
-                `'${`00${this.$utils.escape(day)}`.slice(-2)}'`,
-            ]
-                .join(" ")
-                .replace(/^\s+/, ""),
+            ...this.$state.get("WHERE"),
+            {
+                column: `DAY(${this.bindColumn(String(column))})`,
+                operator: '=',
+                value: `'${`00${this.$utils.escape(day)}`.slice(-2)}'`,
+            }
         ]);
         return this;
     }
@@ -2477,17 +3062,13 @@ class Model extends AbstractModel_1.AbstractModel {
      * @returns {this}
      */
     whereMonth(column, month) {
-        const wheres = this.$state.get("WHERE");
         this.$state.set("WHERE", [
-            ...wheres,
-            [
-                wheres.length ? `${this.$constants("AND")}` : "",
-                `MONTH(${this.bindColumn(String(column))})`,
-                `=`,
-                `'${`00${this.$utils.escape(month)}`.slice(-2)}'`,
-            ]
-                .join(" ")
-                .replace(/^\s+/, ""),
+            ...this.$state.get("WHERE"),
+            {
+                column: `MONTH(${this.bindColumn(String(column))})`,
+                operator: '=',
+                value: `'${`00${this.$utils.escape(month)}`.slice(-2)}'`,
+            }
         ]);
         return this;
     }
@@ -2498,17 +3079,13 @@ class Model extends AbstractModel_1.AbstractModel {
      * @returns {this}
      */
     whereYear(column, year) {
-        const wheres = this.$state.get("WHERE");
         this.$state.set("WHERE", [
-            ...wheres,
-            [
-                wheres.length ? `${this.$constants("AND")}` : "",
-                `YEAR(${this.bindColumn(String(column))})`,
-                `=`,
-                `'${`0000${this.$utils.escape(year)}`.slice(-4)}'`,
-            ]
-                .join(" ")
-                .replace(/^\s+/, ""),
+            ...this.$state.get("WHERE"),
+            {
+                column: `YEAR(${this.bindColumn(String(column))})`,
+                operator: '=',
+                value: `'${`0000${this.$utils.escape(year)}`.slice(-2)}'`,
+            }
         ]);
         return this;
     }
@@ -2579,9 +3156,11 @@ class Model extends AbstractModel_1.AbstractModel {
                 }
                 default: {
                     if (useOp.op.includes("|")) {
+                        //@ts-ignore
                         this.orWhere(c, useOp.op.replace("|", ""), useOp.value);
                         break;
                     }
+                    //@ts-ignore
                     this.where(c, useOp.op, useOp.value);
                 }
             }
@@ -2598,19 +3177,14 @@ class Model extends AbstractModel_1.AbstractModel {
      * @returns   {this}
      */
     whereJSON(column, { key, value, operator }) {
-        value = this.$utils.escape(value);
-        value = this.$utils.transfromBooleanToNumber(value);
-        const wheres = this.$state.get("WHERE");
+        const formatedValue = this.$utils.formatQueryValue(value);
         this.$state.set("WHERE", [
-            ...wheres,
-            [
-                wheres.length ? `${this.$constants("AND")}` : "",
-                `${this.bindColumn(String(column))}->>'$.${key}'`,
-                `${operator == null ? "=" : operator.toLocaleUpperCase()}`,
-                `${this.$utils.transfromValueHasRaw(value)}`,
-            ]
-                .join(" ")
-                .replace(/^\s+/, ""),
+            ...this.$state.get("WHERE"),
+            {
+                column: `${this.bindColumn(String(column))}->>'$.${key}'`,
+                operator: `${operator == null ? "=" : operator.toLocaleUpperCase()}`,
+                value: formatedValue
+            }
         ]);
         return this;
     }
@@ -2633,15 +3207,14 @@ class Model extends AbstractModel_1.AbstractModel {
      * @returns {this}
      */
     whereUser(userId, column = "user_id") {
-        const wheres = this.$state.get("WHERE");
+        const formatedValue = this.$utils.formatQueryValue(userId);
         this.$state.set("WHERE", [
-            ...wheres,
-            [
-                wheres.length ? `${this.$constants("AND")}` : "",
-                `${this.bindColumn(column)} = ${this.$utils.escape(userId)}`,
-            ]
-                .join(" ")
-                .replace(/^\s+/, ""),
+            ...this.$state.get("WHERE"),
+            {
+                column: this.bindColumn(String(column)),
+                operator: '=',
+                value: formatedValue
+            }
         ]);
         return this;
     }
@@ -2654,14 +3227,11 @@ class Model extends AbstractModel_1.AbstractModel {
         if (sql instanceof Model && !sql.$state.get("SELECT").length) {
             sql.select1();
         }
-        const wheres = this.$state.get("WHERE");
         this.$state.set("WHERE", [
-            ...wheres,
-            [
-                wheres.length ? `${this.$constants("AND")}` : "",
-                `${this.$constants("EXISTS")}`,
-                `(${sql})`,
-            ].join(" "),
+            ...this.$state.get("WHERE"),
+            {
+                value: `${this.$constants("EXISTS")} (${sql})`
+            }
         ]);
         return this;
     }
@@ -2674,29 +3244,32 @@ class Model extends AbstractModel_1.AbstractModel {
     whereIn(column, array) {
         if (!Array.isArray(array))
             array = [array];
-        const values = array.length
-            ? `${array
-                .map((value) => this.$utils.transfromValueHasRaw(this.$utils.escape(value)))
-                .join(",")}`
-            : this.$constants(this.$constants("NULL"));
+        if (!array.length) {
+            array = [DB_1.DB.raw(this.$constants("NULL"))];
+        }
         const blueprint = this._getBlueprintByColumn(String(column));
         if (blueprint?.isVirtual) {
+            const values = array.length ? `${array
+                .map((value) => {
+                return this.$utils.formatQueryValue(value);
+            })
+                .join(",")}`
+                : this.$constants(this.$constants("NULL"));
             const sql = blueprint.sql?.where;
             if (sql) {
                 return this.whereRaw(`${sql} ${this.$constants("IN")} (${values})`);
             }
         }
-        const wheres = this.$state.get("WHERE");
         this.$state.set("WHERE", [
-            ...wheres,
-            [
-                wheres.length ? `${this.$constants("AND")}` : "",
-                `${this.bindColumn(String(column))}`,
-                `${this.$constants("IN")}`,
-                `(${values})`,
-            ]
-                .join(" ")
-                .replace(/^\s+/, ""),
+            ...this.$state.get("WHERE"),
+            {
+                column: this.bindColumn(String(column)),
+                operator: `${this.$constants("IN")}`,
+                value: array
+                    .map((value) => {
+                    return this.$utils.formatQueryValue(value);
+                })
+            }
         ]);
         return this;
     }
@@ -2709,22 +3282,33 @@ class Model extends AbstractModel_1.AbstractModel {
     orWhereIn(column, array) {
         if (!Array.isArray(array))
             array = [array];
-        const values = array.length
-            ? `${array
-                .map((value) => this.$utils.transfromValueHasRaw(this.$utils.escape(value)))
+        if (!array.length) {
+            array = [DB_1.DB.raw(this.$constants("NULL"))];
+        }
+        const blueprint = this._getBlueprintByColumn(String(column));
+        if (blueprint?.isVirtual) {
+            const values = array.length ? `${array
+                .map((value) => {
+                return this.$utils.formatQueryValue(value);
+            })
                 .join(",")}`
-            : this.$constants(this.$constants("NULL"));
-        const wheres = this.$state.get("WHERE");
+                : this.$constants(this.$constants("NULL"));
+            const sql = blueprint.sql?.where;
+            if (sql) {
+                return this.orWhereRaw(`${sql} ${this.$constants("IN")} (${values})`);
+            }
+        }
         this.$state.set("WHERE", [
-            ...wheres,
-            [
-                wheres.length ? `${this.$constants("OR")}` : "",
-                `${this.bindColumn(String(column))}`,
-                `${this.$constants("IN")}`,
-                `(${values})`,
-            ]
-                .join(" ")
-                .replace(/^\s+/, ""),
+            ...this.$state.get("WHERE"),
+            {
+                column: this.bindColumn(String(column)),
+                condition: 'OR',
+                operator: `${this.$constants("IN")}`,
+                value: array
+                    .map((value) => {
+                    return this.$utils.formatQueryValue(value);
+                })
+            }
         ]);
         return this;
     }
@@ -2737,22 +3321,32 @@ class Model extends AbstractModel_1.AbstractModel {
     whereNotIn(column, array) {
         if (!Array.isArray(array))
             array = [array];
-        if (!array.length)
-            return this;
-        const values = `${array
-            .map((value) => this.$utils.transfromValueHasRaw(this.$utils.escape(value)))
-            .join(",")}`;
-        const wheres = this.$state.get("WHERE");
+        if (!array.length) {
+            array = [DB_1.DB.raw(this.$constants("NULL"))];
+        }
+        const blueprint = this._getBlueprintByColumn(String(column));
+        if (blueprint?.isVirtual) {
+            const values = array.length ? `${array
+                .map((value) => {
+                return this.$utils.formatQueryValue(value);
+            })
+                .join(",")}`
+                : this.$constants(this.$constants("NULL"));
+            const sql = blueprint.sql?.where;
+            if (sql) {
+                return this.whereRaw(`${sql} ${this.$constants("NOT_IN")} (${values})`);
+            }
+        }
         this.$state.set("WHERE", [
-            ...wheres,
-            [
-                wheres.length ? `${this.$constants("AND")}` : "",
-                `${this.bindColumn(String(column))}`,
-                `${this.$constants("NOT_IN")}`,
-                `(${values})`,
-            ]
-                .join(" ")
-                .replace(/^\s+/, ""),
+            ...this.$state.get("WHERE"),
+            {
+                column: this.bindColumn(String(column)),
+                operator: `${this.$constants("NOT_IN")}`,
+                value: array
+                    .map((value) => {
+                    return this.$utils.formatQueryValue(value);
+                })
+            }
         ]);
         return this;
     }
@@ -2765,22 +3359,33 @@ class Model extends AbstractModel_1.AbstractModel {
     orWhereNotIn(column, array) {
         if (!Array.isArray(array))
             array = [array];
-        if (!array.length)
-            return this;
-        const values = `${array
-            .map((value) => this.$utils.transfromValueHasRaw(this.$utils.escape(value)))
-            .join(",")}`;
-        const wheres = this.$state.get("WHERE");
+        if (!array.length) {
+            array = [DB_1.DB.raw(this.$constants("NULL"))];
+        }
+        const blueprint = this._getBlueprintByColumn(String(column));
+        if (blueprint?.isVirtual) {
+            const values = array.length ? `${array
+                .map((value) => {
+                return this.$utils.formatQueryValue(value);
+            })
+                .join(",")}`
+                : this.$constants(this.$constants("NULL"));
+            const sql = blueprint.sql?.where;
+            if (sql) {
+                return this.orWhereRaw(`${sql} ${this.$constants("NOT_IN")} (${values})`);
+            }
+        }
         this.$state.set("WHERE", [
-            ...wheres,
-            [
-                wheres.length ? `${this.$constants("OR")}` : "",
-                `${this.bindColumn(String(column))}`,
-                `${this.$constants("NOT_IN")}`,
-                `(${values})`,
-            ]
-                .join(" ")
-                .replace(/^\s+/, ""),
+            ...this.$state.get("WHERE"),
+            {
+                column: this.bindColumn(String(column)),
+                operator: `${this.$constants("NOT_IN")}`,
+                condition: 'OR',
+                value: array
+                    .map((value) => {
+                    return this.$utils.formatQueryValue(value);
+                })
+            }
         ]);
         return this;
     }
@@ -2794,17 +3399,13 @@ class Model extends AbstractModel_1.AbstractModel {
         if (subQuery instanceof Model && !subQuery.$state.get("SELECT").length) {
             subQuery.select("id");
         }
-        const wheres = this.$state.get("WHERE");
         this.$state.set("WHERE", [
-            ...wheres,
-            [
-                wheres.length ? `${this.$constants("AND")}` : "",
-                `${this.bindColumn(String(column))}`,
-                options.operator,
-                `(${subQuery})`,
-            ]
-                .join(" ")
-                .replace(/^\s+/, ""),
+            ...this.$state.get("WHERE"),
+            {
+                column: this.bindColumn(String(column)),
+                operator: options.operator,
+                value: `(${subQuery})`
+            }
         ]);
         return this;
     }
@@ -2818,17 +3419,13 @@ class Model extends AbstractModel_1.AbstractModel {
         if (subQuery instanceof Model && !subQuery.$state.get("SELECT").length) {
             subQuery.select("id");
         }
-        const wheres = this.$state.get("WHERE");
         this.$state.set("WHERE", [
-            ...wheres,
-            [
-                wheres.length ? `${this.$constants("AND")}` : "",
-                `${this.bindColumn(String(column))}`,
-                options.operator,
-                `(${subQuery})`,
-            ]
-                .join(" ")
-                .replace(/^\s+/, ""),
+            ...this.$state.get("WHERE"),
+            {
+                column: this.bindColumn(String(column)),
+                operator: options.operator,
+                value: `(${subQuery})`
+            }
         ]);
         return this;
     }
@@ -2842,17 +3439,14 @@ class Model extends AbstractModel_1.AbstractModel {
         if (subQuery instanceof Model && !subQuery.$state.get("SELECT").length) {
             subQuery.select("id");
         }
-        const wheres = this.$state.get("WHERE");
         this.$state.set("WHERE", [
-            ...wheres,
-            [
-                wheres.length ? `${this.$constants("OR")}` : "",
-                `${this.bindColumn(String(column))}`,
-                options.operator,
-                `(${subQuery})`,
-            ]
-                .join(" ")
-                .replace(/^\s+/, ""),
+            ...this.$state.get("WHERE"),
+            {
+                column: this.bindColumn(String(column)),
+                operator: options.operator,
+                condition: 'OR',
+                value: `(${subQuery})`
+            }
         ]);
         return this;
     }
@@ -2866,17 +3460,14 @@ class Model extends AbstractModel_1.AbstractModel {
         if (subQuery instanceof Model && !subQuery.$state.get("SELECT").length) {
             subQuery.select("id");
         }
-        const wheres = this.$state.get("WHERE");
         this.$state.set("WHERE", [
-            ...wheres,
-            [
-                wheres.length ? `${this.$constants("OR")}` : "",
-                `${this.bindColumn(String(column))}`,
-                options.operator,
-                `(${subQuery})`,
-            ]
-                .join(" ")
-                .replace(/^\s+/, ""),
+            ...this.$state.get("WHERE"),
+            {
+                column: this.bindColumn(String(column)),
+                operator: options.operator,
+                condition: 'OR',
+                value: `(${subQuery})`
+            }
         ]);
         return this;
     }
@@ -2887,36 +3478,24 @@ class Model extends AbstractModel_1.AbstractModel {
      * @returns {this}
      */
     whereBetween(column, array) {
-        const wheres = this.$state.get("WHERE");
         if (!array.length) {
-            this.$state.set("WHERE", [
-                ...wheres,
-                [
-                    wheres.length ? `${this.$constants("AND")}` : "",
-                    `${this.bindColumn(String(column))}`,
-                    `${this.$constants("BETWEEN")}`,
-                    `${this.$constants(this.$constants("NULL"))}`,
-                    `${this.$constants("AND")}`,
-                    `${this.$constants(this.$constants("NULL"))}`,
-                ]
-                    .join(" ")
-                    .replace(/^\s+/, ""),
+            return this.whereBetween(column, [
+                DB_1.DB.raw(this.$constants("NULL")),
+                DB_1.DB.raw(this.$constants("NULL"))
             ]);
-            return this;
         }
-        const [value1, value2] = array;
+        let [value1, value2] = array;
         this.$state.set("WHERE", [
-            ...wheres,
-            [
-                wheres.length ? `${this.$constants("AND")}` : "",
-                `${this.bindColumn(String(column))}`,
-                `${this.$constants("BETWEEN")}`,
-                `${this.$utils.transfromValueHasRaw(this.$utils.escape(value1))}`,
-                `${this.$constants("AND")}`,
-                `${this.$utils.transfromValueHasRaw(this.$utils.escape(value2))}`,
-            ]
-                .join(" ")
-                .replace(/^\s+/, ""),
+            ...this.$state.get("WHERE"),
+            {
+                column: this.bindColumn(String(column)),
+                operator: `${this.$constants("BETWEEN")}`,
+                value: [
+                    `${this.$utils.formatQueryValue(value1)}`,
+                    `${this.$constants("AND")}`,
+                    `${this.$utils.formatQueryValue(value2)}`,
+                ].join(" ")
+            }
         ]);
         return this;
     }
@@ -2927,36 +3506,22 @@ class Model extends AbstractModel_1.AbstractModel {
      * @returns {this}
      */
     orWhereBetween(column, array) {
-        const wheres = this.$state.get("WHERE");
         if (!array.length) {
-            this.$state.set("WHERE", [
-                ...wheres,
-                [
-                    wheres.length ? `${this.$constants("OR")}` : "",
-                    `${this.bindColumn(String(column))}`,
-                    `${this.$constants("BETWEEN")}`,
-                    `${this.$constants(this.$constants("NULL"))}`,
-                    `${this.$constants("AND")}`,
-                    `${this.$constants(this.$constants("NULL"))}`,
-                ]
-                    .join(" ")
-                    .replace(/^\s+/, ""),
-            ]);
-            return this;
+            return this.orWhereBetween(column, [DB_1.DB.raw(this.$constants("NULL")), DB_1.DB.raw(this.$constants("NULL"))]);
         }
-        const [value1, value2] = array;
+        let [value1, value2] = array;
         this.$state.set("WHERE", [
-            ...wheres,
-            [
-                wheres.length ? `${this.$constants("OR")}` : "",
-                `${this.bindColumn(String(column))}`,
-                `${this.$constants("BETWEEN")}`,
-                `${this.$utils.transfromValueHasRaw(this.$utils.escape(value1))}`,
-                `${this.$constants("AND")}`,
-                `${this.$utils.transfromValueHasRaw(this.$utils.escape(value2))}`,
-            ]
-                .join(" ")
-                .replace(/^\s+/, ""),
+            ...this.$state.get("WHERE"),
+            {
+                column: this.bindColumn(String(column)),
+                operator: `${this.$constants("BETWEEN")}`,
+                condition: 'OR',
+                value: [
+                    `${this.$utils.formatQueryValue(value1)}`,
+                    `${this.$constants("AND")}`,
+                    `${this.$utils.formatQueryValue(value2)}`
+                ].join(" ")
+            }
         ]);
         return this;
     }
@@ -2967,36 +3532,24 @@ class Model extends AbstractModel_1.AbstractModel {
      * @returns {this}
      */
     whereNotBetween(column, array) {
-        const wheres = this.$state.get("WHERE");
         if (!array.length) {
-            this.$state.set("WHERE", [
-                ...wheres,
-                [
-                    wheres.length ? `${this.$constants("AND")}` : "",
-                    `${this.bindColumn(String(column))}`,
-                    `${this.$constants("NOT_BETWEEN")}`,
-                    `${this.$constants(this.$constants("NULL"))}`,
-                    `${this.$constants("AND")}`,
-                    `${this.$constants(this.$constants("NULL"))}`,
-                ]
-                    .join(" ")
-                    .replace(/^\s+/, ""),
+            return this.whereNotBetween(column, [
+                DB_1.DB.raw(this.$constants("NULL")),
+                DB_1.DB.raw(this.$constants("NULL"))
             ]);
-            return this;
         }
         const [value1, value2] = array;
         this.$state.set("WHERE", [
-            ...wheres,
-            [
-                wheres.length ? `${this.$constants("AND")}` : "",
-                `${this.bindColumn(String(column))}`,
-                `${this.$constants("NOT_BETWEEN")}`,
-                `${this.$utils.transfromValueHasRaw(this.$utils.escape(value1))}`,
-                `${this.$constants("AND")}`,
-                `${this.$utils.transfromValueHasRaw(this.$utils.escape(value2))}`,
-            ]
-                .join(" ")
-                .replace(/^\s+/, ""),
+            ...this.$state.get("WHERE"),
+            {
+                column: this.bindColumn(String(column)),
+                operator: `${this.$constants("NOT_BETWEEN")}`,
+                value: [
+                    `${this.$utils.formatQueryValue(value1)}`,
+                    `${this.$constants("AND")}`,
+                    `${this.$utils.formatQueryValue(value2)}`,
+                ].join(" ")
+            }
         ]);
         return this;
     }
@@ -3007,36 +3560,25 @@ class Model extends AbstractModel_1.AbstractModel {
      * @returns {this}
      */
     orWhereNotBetween(column, array) {
-        const wheres = this.$state.get("WHERE");
         if (!array.length) {
-            this.$state.set("WHERE", [
-                ...wheres,
-                [
-                    wheres.length ? `${this.$constants("OR")}` : "",
-                    `${this.bindColumn(String(column))}`,
-                    `${this.$constants("NOT_BETWEEN")}`,
-                    `${this.$constants(this.$constants("NULL"))}`,
-                    `${this.$constants("AND")}`,
-                    `${this.$constants(this.$constants("NULL"))}`,
-                ]
-                    .join(" ")
-                    .replace(/^\s+/, ""),
+            return this.orWhereNotBetween(column, [
+                DB_1.DB.raw(this.$constants("NULL")),
+                DB_1.DB.raw(this.$constants("NULL"))
             ]);
-            return this;
         }
         const [value1, value2] = array;
         this.$state.set("WHERE", [
             ...this.$state.get("WHERE"),
-            [
-                this.$state.get("WHERE").length ? `${this.$constants("OR")}` : "",
-                `${this.bindColumn(String(column))}`,
-                `${this.$constants("NOT_BETWEEN")}`,
-                `${this.$utils.transfromValueHasRaw(this.$utils.escape(value1))}`,
-                `${this.$constants("AND")}`,
-                `${this.$utils.transfromValueHasRaw(this.$utils.escape(value2))}`,
-            ]
-                .join(" ")
-                .replace(/^\s+/, ""),
+            {
+                column: this.bindColumn(String(column)),
+                operator: `${this.$constants("NOT_BETWEEN")}`,
+                condition: 'OR',
+                value: [
+                    `${this.$utils.formatQueryValue(value1)}`,
+                    `${this.$constants("AND")}`,
+                    `${this.$utils.formatQueryValue(value2)}`,
+                ].join(" ")
+            }
         ]);
         return this;
     }
@@ -3046,16 +3588,12 @@ class Model extends AbstractModel_1.AbstractModel {
      * @returns {this}
      */
     whereNull(column) {
-        const wheres = this.$state.get("WHERE");
         this.$state.set("WHERE", [
-            ...wheres,
-            [
-                wheres.length ? `${this.$constants("AND")}` : "",
-                `${this.bindColumn(String(column))}`,
-                `${this.$constants("IS_NULL")}`,
-            ]
-                .join(" ")
-                .replace(/^\s+/, ""),
+            ...this.$state.get("WHERE"),
+            {
+                column: this.bindColumn(String(column)),
+                operator: `${this.$constants("IS_NULL")}`,
+            }
         ]);
         return this;
     }
@@ -3065,16 +3603,13 @@ class Model extends AbstractModel_1.AbstractModel {
      * @returns {this}
      */
     orWhereNull(column) {
-        const wheres = this.$state.get("WHERE");
         this.$state.set("WHERE", [
-            ...wheres,
-            [
-                wheres.length ? `${this.$constants("OR")}` : "",
-                `${this.bindColumn(String(column))}`,
-                `${this.$constants("IS_NULL")}`,
-            ]
-                .join(" ")
-                .replace(/^\s+/, ""),
+            ...this.$state.get("WHERE"),
+            {
+                column: this.bindColumn(String(column)),
+                operator: `${this.$constants("IS_NULL")}`,
+                condition: 'OR'
+            }
         ]);
         return this;
     }
@@ -3084,16 +3619,12 @@ class Model extends AbstractModel_1.AbstractModel {
      * @returns {this}
      */
     whereNotNull(column) {
-        const wheres = this.$state.get("WHERE");
         this.$state.set("WHERE", [
-            ...wheres,
-            [
-                wheres.length ? `${this.$constants("AND")}` : "",
-                `${this.bindColumn(String(column))}`,
-                `${this.$constants("IS_NOT_NULL")}`,
-            ]
-                .join(" ")
-                .replace(/^\s+/, ""),
+            ...this.$state.get("WHERE"),
+            {
+                column: this.bindColumn(String(column)),
+                operator: `${this.$constants("IS_NOT_NULL")}`,
+            }
         ]);
         return this;
     }
@@ -3103,16 +3634,13 @@ class Model extends AbstractModel_1.AbstractModel {
      * @returns {this}
      */
     orWhereNotNull(column) {
-        const wheres = this.$state.get("WHERE");
         this.$state.set("WHERE", [
-            ...wheres,
-            [
-                wheres.length ? `${this.$constants("OR")}` : "",
-                `${this.bindColumn(String(column))}`,
-                `${this.$constants("IS_NOT_NULL")}`,
-            ]
-                .join(" ")
-                .replace(/^\s+/, ""),
+            ...this.$state.get("WHERE"),
+            {
+                column: this.bindColumn(String(column)),
+                operator: `${this.$constants("IS_NOT_NULL")}`,
+                condition: 'OR'
+            }
         ]);
         return this;
     }
@@ -3125,20 +3653,13 @@ class Model extends AbstractModel_1.AbstractModel {
      */
     whereSensitive(column, operator, value) {
         [value, operator] = this.$utils.valueAndOperator(value, operator, arguments.length === 2);
-        value = this.$utils.escape(value);
-        value = this.$utils.transfromBooleanToNumber(value);
-        const wheres = this.$state.get("WHERE");
         this.$state.set("WHERE", [
-            ...wheres,
-            [
-                wheres.length ? `${this.$constants("AND")}` : "",
-                `${this.$constants("BINARY")}`,
-                `${this.bindColumn(String(column))}`,
-                `${operator}`,
-                `${this.$utils.transfromValueHasRaw(this.$utils.escape(value))}`,
-            ]
-                .join(" ")
-                .replace(/^\s+/, ""),
+            ...this.$state.get("WHERE"),
+            {
+                column: `${this.$constants("BINARY")} ${this.bindColumn(String(column))}`,
+                operator,
+                value: `${this.$utils.formatQueryValue(value)}`
+            }
         ]);
         return this;
     }
@@ -3151,20 +3672,13 @@ class Model extends AbstractModel_1.AbstractModel {
      */
     whereStrict(column, operator, value) {
         [value, operator] = this.$utils.valueAndOperator(value, operator, arguments.length === 2);
-        value = this.$utils.escape(value);
-        value = this.$utils.transfromBooleanToNumber(value);
-        const wheres = this.$state.get("WHERE");
         this.$state.set("WHERE", [
-            ...wheres,
-            [
-                wheres.length ? `${this.$constants("AND")}` : "",
-                `${this.$constants("BINARY")}`,
-                `${this.bindColumn(String(column))}`,
-                `${operator}`,
-                `${this.$utils.transfromValueHasRaw(this.$utils.escape(value))}`,
-            ]
-                .join(" ")
-                .replace(/^\s+/, ""),
+            ...this.$state.get("WHERE"),
+            {
+                column: `${this.$constants("BINARY")} ${this.bindColumn(String(column))}`,
+                operator,
+                value: `${this.$utils.formatQueryValue(value)}`,
+            }
         ]);
         return this;
     }
@@ -3177,20 +3691,14 @@ class Model extends AbstractModel_1.AbstractModel {
      */
     orWhereSensitive(column, operator, value) {
         [value, operator] = this.$utils.valueAndOperator(value, operator, arguments.length === 2);
-        value = this.$utils.escape(value);
-        value = this.$utils.transfromBooleanToNumber(value);
-        const wheres = this.$state.get("WHERE");
         this.$state.set("WHERE", [
-            ...wheres,
-            [
-                wheres.length ? `${this.$constants("OR")}` : "",
-                `${this.$constants("BINARY")}`,
-                `${this.bindColumn(String(column))}`,
-                `${operator}`,
-                `${this.$utils.transfromValueHasRaw(this.$utils.escape(value))}`,
-            ]
-                .join(" ")
-                .replace(/^\s+/, ""),
+            ...this.$state.get("WHERE"),
+            {
+                column: `${this.$constants("BINARY")} ${this.bindColumn(String(column))}`,
+                operator,
+                condition: 'OR',
+                value: `${this.$utils.formatQueryValue(value)}`,
+            }
         ]);
         return this;
     }
@@ -3240,16 +3748,29 @@ class Model extends AbstractModel_1.AbstractModel {
         const where = repository?.$state.get("WHERE") || [];
         if (!where.length)
             return this;
-        const query = where.join(" ");
-        const wheres = this.$state.get("WHERE");
         this.$state.set("WHERE", [
-            ...wheres,
-            [
-                wheres.length ? `${this.$constants("AND")}` : "",
-                `(${query})`,
-            ]
-                .join(" ")
-                .replace(/^\s+/, ""),
+            ...this.$state.get("WHERE"),
+            ...this.$utils.nestConditions(repository?.$state.get("WHERE"))
+        ]);
+        return this;
+    }
+    /**
+     * @override
+     * @param {Function} callback callback query
+     * @returns {this}
+     */
+    orWhereQuery(callback) {
+        const copy = new Model().copyModel(this);
+        const repository = callback(copy);
+        if (repository instanceof Promise) {
+            throw this._assertError('The "orWhereQuery" method is not supported a Promise');
+        }
+        if (!(repository instanceof Model)) {
+            throw this._assertError(`Unknown callback query: '${repository}'`);
+        }
+        this.$state.set("WHERE", [
+            ...this.$state.get("WHERE"),
+            ...this.$utils.nestConditions(repository?.$state.get("WHERE"), 'OR')
         ]);
         return this;
     }
@@ -3262,8 +3783,6 @@ class Model extends AbstractModel_1.AbstractModel {
      */
     whereAny(columns, operator, value) {
         [value, operator] = this.$utils.valueAndOperator(value, operator, arguments.length === 2);
-        value = this.$utils.escape(value);
-        value = this.$utils.transfromBooleanToNumber(value);
         this.whereQuery((query) => {
             for (const index in columns) {
                 const column = String(columns[index]);
@@ -3290,8 +3809,6 @@ class Model extends AbstractModel_1.AbstractModel {
      */
     whereAll(columns, operator, value) {
         [value, operator] = this.$utils.valueAndOperator(value, operator, arguments.length === 2);
-        value = this.$utils.escape(value);
-        value = this.$utils.transfromBooleanToNumber(value);
         this.whereQuery((query) => {
             for (const key in columns) {
                 const column = String(columns[key]);
@@ -3361,11 +3878,20 @@ class Model extends AbstractModel_1.AbstractModel {
      * @returns {this}
      */
     join(localKey, referenceKey) {
-        if ((typeof localKey === "function" && typeof localKey === "function") &&
-            (this._isModel(localKey) && this._isModel(referenceKey))) {
-            return this.joinModel(localKey, referenceKey);
+        if (typeof localKey === 'string') {
+            this._handleJoin("INNER_JOIN", localKey, referenceKey);
+            return this;
+        }
+        if (typeof localKey === "function" && !this._isModel(localKey)) {
+            const cb = localKey;
+            const callback = cb(new Join_1.Join(this, "INNER_JOIN"));
+            this.$state.set("JOIN", [
+                ...this.$state.get("JOIN"),
+                callback["toString"](),
+            ]);
+            return this;
         }
-        this._handleJoin("INNER_JOIN", localKey, referenceKey);
+        this.joinModel(localKey, referenceKey);
         return this;
     }
     /**
@@ -3376,11 +3902,20 @@ class Model extends AbstractModel_1.AbstractModel {
      * @returns {this}
      */
     rightJoin(localKey, referenceKey) {
-        if ((typeof localKey === "function" && typeof localKey === "function") &&
-            (this._isModel(localKey) && this._isModel(referenceKey))) {
-            return this.joinModel(localKey, referenceKey);
+        if (typeof localKey === 'string') {
+            this._handleJoin("RIGHT_JOIN", localKey, referenceKey);
+            return this;
+        }
+        if (typeof localKey === "function" && !this._isModel(localKey)) {
+            const cb = localKey;
+            const callback = cb(new Join_1.Join(this, "RIGHT_JOIN"));
+            this.$state.set("JOIN", [
+                ...this.$state.get("JOIN"),
+                callback["toString"](),
+            ]);
+            return this;
         }
-        this._handleJoin("RIGHT_JOIN", localKey, referenceKey);
+        this.rightJoinModel(localKey, referenceKey);
         return this;
     }
     /**
@@ -3391,11 +3926,20 @@ class Model extends AbstractModel_1.AbstractModel {
      * @returns {this}
      */
     leftJoin(localKey, referenceKey) {
-        if ((typeof localKey === "function" && typeof localKey === "function") &&
-            (this._isModel(localKey) && this._isModel(referenceKey))) {
-            return this.joinModel(localKey, referenceKey);
+        if (typeof localKey === 'string') {
+            this._handleJoin("LEFT_JOIN", localKey, referenceKey);
+            return this;
+        }
+        if (typeof localKey === "function" && !this._isModel(localKey)) {
+            const cb = localKey;
+            const callback = cb(new Join_1.Join(this, "LEFT_JOIN"));
+            this.$state.set("JOIN", [
+                ...this.$state.get("JOIN"),
+                callback["toString"](),
+            ]);
+            return this;
         }
-        this._handleJoin("LEFT_JOIN", localKey, referenceKey);
+        this.leftJoinModel(localKey, referenceKey);
         return this;
     }
     /**
@@ -3405,11 +3949,20 @@ class Model extends AbstractModel_1.AbstractModel {
      * @returns {this}
      */
     crossJoin(localKey, referenceKey) {
-        if ((typeof localKey === "function" && typeof localKey === "function") &&
-            (this._isModel(localKey) && this._isModel(referenceKey))) {
-            return this.joinModel(localKey, referenceKey);
+        if (typeof localKey === 'string') {
+            this._handleJoin("CROSS_JOIN", localKey, referenceKey);
+            return this;
+        }
+        if (typeof localKey === "function" && !this._isModel(localKey)) {
+            const cb = localKey;
+            const callback = cb(new Join_1.Join(this, "CROSS_JOIN"));
+            this.$state.set("JOIN", [
+                ...this.$state.get("JOIN"),
+                callback["toString"](),
+            ]);
+            return this;
         }
-        this._handleJoin("CROSS_JOIN", localKey, referenceKey);
+        this.crossJoinModel(localKey, referenceKey);
         return this;
     }
     /**
@@ -3455,8 +4008,10 @@ class Model extends AbstractModel_1.AbstractModel {
             ]);
             return this;
         }
-        if (m2 == null)
-            return this;
+        if (this._isModel(m1) && m2 == null) {
+            m2 = m1;
+            m1 = this;
+        }
         const { alias1, alias2, table1, table2, model1, model2, localKey, foreignKey, } = this._handleJoinModel(m1, m2);
         this.join(`${alias1 === "" ? table1 : `${table1}|${alias1}`}.${localKey}`, `${alias2 === "" ? table2 : `${table2}|${alias2}`}.${foreignKey}`);
         if (model1["$state"].get("MODEL_NAME") !== this["$state"].get("MODEL_NAME")) {
@@ -3519,8 +4074,10 @@ class Model extends AbstractModel_1.AbstractModel {
             ]);
             return this;
         }
-        if (m2 == null)
-            return this;
+        if (this._isModel(m1) && m2 == null) {
+            m2 = m1;
+            m1 = this;
+        }
         const { alias1, alias2, table1, table2, model1, model2, localKey, foreignKey, } = this._handleJoinModel(m1, m2);
         this.leftJoin(`${alias1 === "" ? table1 : `${table1}|${alias1}`}.${localKey}`, `${alias2 === "" ? table2 : `${table2}|${alias2}`}.${foreignKey}`);
         if (model1["$state"].get("MODEL_NAME") !== this["$state"].get("MODEL_NAME")) {
@@ -3562,6 +4119,104 @@ class Model extends AbstractModel_1.AbstractModel {
         }
         return this;
     }
+    /**
+     *
+     * @override
+     * @param {string=} c [column=id]
+     * @returns {promise<number>}
+     */
+    async count(c) {
+        await this._prepareQueryPipeline();
+        const distinct = this.$state.get("DISTINCT");
+        let column = c == null ? this.$state.get('PRIMARY_KEY') : String(c);
+        column =
+            column === "*"
+                ? "*"
+                : distinct
+                    ? `${this.$constants("DISTINCT")} ${this.bindColumn(column)}`
+                    : `${this.bindColumn(column)}`;
+        this.selectRaw([
+            `${this.$constants("COUNT")}(${column})`,
+            `${this.$constants("AS")}`,
+            "\`aggregate\`",
+        ].join(" "));
+        const sql = this._queryBuilder().select();
+        const result = await this._queryStatement(sql);
+        return Number(this._resultHandler(result.reduce((prev, cur) => prev + Number(cur?.aggregate ?? 0), 0) || 0));
+    }
+    /**
+     *
+     * @override
+     * @param {string=} c [column=id]
+     * @returns {promise<number>}
+     */
+    async avg(c) {
+        await this._prepareQueryPipeline();
+        const distinct = this.$state.get("DISTINCT");
+        let column = c == null ? this.$state.get('PRIMARY_KEY') : String(c);
+        column = distinct
+            ? `${this.$constants("DISTINCT")} ${this.bindColumn(column)}`
+            : `${this.bindColumn(column)}`;
+        this.selectRaw(`${this.$constants("AVG")}(${column}) ${this.$constants("AS")} \`aggregate\``);
+        const sql = this._queryBuilder().select();
+        const result = await this._queryStatement(sql);
+        return Number(this._resultHandler((result.reduce((prev, cur) => prev + Number(cur?.aggregate ?? 0), 0) ||
+            0) / result.length));
+    }
+    /**
+     *
+     * @override
+     * @param {string=} c [column=id]
+     * @returns {promise<number>}
+     */
+    async sum(c) {
+        await this._prepareQueryPipeline();
+        let column = c == null ? this.$state.get('PRIMARY_KEY') : String(c);
+        const distinct = this.$state.get("DISTINCT");
+        column = distinct
+            ? `${this.$constants("DISTINCT")} ${this.bindColumn(column)}`
+            : `${this.bindColumn(column)}`;
+        this.selectRaw(`${this.$constants("SUM")}(${column}) ${this.$constants("AS")} \`aggregate\``);
+        const sql = this._queryBuilder().select();
+        const result = await this._queryStatement(sql);
+        return Number(this._resultHandler(result.reduce((prev, cur) => prev + Number(cur?.aggregate ?? 0), 0) ||
+            0));
+    }
+    /**
+     *
+     * @override
+     * @param {string=} c [column=id]
+     * @returns {promise<number>}
+     */
+    async max(c) {
+        await this._prepareQueryPipeline();
+        const distinct = this.$state.get("DISTINCT");
+        let column = c == null ? this.$state.get('PRIMARY_KEY') : String(c);
+        column = distinct
+            ? `${this.$constants("DISTINCT")} ${this.bindColumn(column)}`
+            : `${this.bindColumn(column)}`;
+        this.selectRaw(`${this.$constants("MAX")}(${column}) ${this.$constants("AS")} \`aggregate\``);
+        const sql = this._queryBuilder().select();
+        const result = await this._queryStatement(sql);
+        return Number(this._resultHandler(result.sort((a, b) => b?.aggregate - a?.aggregate)[0]?.aggregate || 0));
+    }
+    /**
+     * @override
+     * @param {string} c
+     * @returns {promise<number>}
+     */
+    async min(c) {
+        await this._prepareQueryPipeline();
+        const distinct = this.$state.get("DISTINCT");
+        let column = c == null ? "id" : String(c);
+        column = distinct
+            ? `${this.$constants("DISTINCT")} ${this.bindColumn(column)}`
+            : `${this.bindColumn(column)}`;
+        this.selectRaw(`${this.$constants("MIN")}(${column}) ${this.$constants("AS")} \`aggregate\``);
+        const sql = this._queryBuilder().select();
+        const result = await this._queryStatement(sql);
+        return Number(this._resultHandler(result.sort((a, b) => a?.aggregate - b?.aggregate)[0]?.aggregate || 0));
+    }
     /**
      * @override
      * @returns {promise<boolean>} promise boolean
@@ -3572,36 +4227,27 @@ class Model extends AbstractModel_1.AbstractModel {
         if (this.$state.get("SOFT_DELETE")) {
             const deletedAt = this._valuePattern(this.$state.get("SOFT_DELETE_FORMAT"));
             await this._runBefore("update");
-            const result = await new Model()
+            const sql = new Model()
                 .copyModel(this, { where: true, limit: true, orderBy: true })
                 .update({
                 [deletedAt]: this.$utils.timestamp(),
             })
-                .disableSoftDelete()
                 .bind(this.$pool.get())
                 .debug(this.$state.get("DEBUG"))
-                .save();
+                .toString();
+            const r = await this._actionStatement(sql);
+            const result = Boolean(this._resultHandler(r?.$meta?.affected || false));
             await this._observer(result, "updated");
             await this._runAfter("update", result);
             return Boolean(this._resultHandler(result));
         }
-        const PK = this.$state.get("PRIMARY_KEY");
-        const TEMP = "TEMP";
-        const from = new Model()
-            .copyModel(this, { where: true, limit: true, orderBy: true })
-            .selectRaw(PK);
-        this
-            .unset({ where: true, limit: true })
-            .select(PK)
-            .whereSubQuery(PK, new Model().from(DB_1.DB.raw(`
-        (${from}) ${this.$constants("AS")} ${TEMP}`)).selectRaw(PK));
         this.$state.set("DELETE", true);
         await this._runBefore("remove");
-        const result = await this._actionStatement(this._queryBuilder().remove());
-        const r = Boolean(this._resultHandler(result?.$meta?.affected || false));
-        await this._observer(r, "deleted");
-        await this._runAfter("remove", r);
-        return r;
+        const r = await this._actionStatement(this._queryBuilder().remove());
+        const result = Boolean(this._resultHandler(r?.$meta?.affected || false));
+        await this._observer(result, "deleted");
+        await this._runAfter("remove", result);
+        return result;
     }
     /**
      * @override
@@ -3612,36 +4258,27 @@ class Model extends AbstractModel_1.AbstractModel {
         if (this.$state.get("SOFT_DELETE")) {
             const deletedAt = this._valuePattern(this.$state.get("SOFT_DELETE_FORMAT"));
             await this._runBefore("update");
-            const result = await new Model()
-                .copyModel(this, { where: true, limit: true })
+            const sql = new Model()
+                .copyModel(this, { where: true, orderBy: true })
                 .updateMany({
                 [deletedAt]: this.$utils.timestamp(),
             })
-                .disableSoftDelete()
-                .debug(this.$state.get("DEBUG"))
                 .bind(this.$pool.get())
-                .save();
+                .debug(this.$state.get("DEBUG"))
+                .toString();
+            const r = await this._actionStatement(sql);
+            const result = Boolean(this._resultHandler(r?.$meta?.affected || false));
             await this._observer(result, "updated");
             await this._runAfter("update", result);
             return Boolean(this._resultHandler(result));
         }
-        const PK = this.$state.get("PRIMARY_KEY");
-        const TEMP = "TEMP";
-        const from = new Model()
-            .copyModel(this, { where: true, limit: true, orderBy: true })
-            .selectRaw(PK);
-        this
-            .unset({ where: true, limit: true })
-            .select(PK)
-            .whereSubQuery(PK, new Model().from(DB_1.DB.raw(`
-        (${from}) ${this.$constants("AS")} ${TEMP}`)).selectRaw(PK));
         this.$state.set("DELETE", true);
         await this._runBefore("remove");
-        const result = await this._actionStatement(this._queryBuilder().remove());
-        const r = Boolean(this._resultHandler(result?.$meta?.affected || false));
-        await this._observer(r, "deleted");
-        await this._runAfter("remove", r);
-        return r;
+        const r = await this._actionStatement(this._queryBuilder().remove());
+        const result = Boolean(this._resultHandler(r?.$meta?.affected || false));
+        await this._observer(result, "deleted");
+        await this._runAfter("remove", result);
+        return result;
     }
     /**
      *
@@ -3654,16 +4291,16 @@ class Model extends AbstractModel_1.AbstractModel {
      */
     async forceDelete() {
         this.disableSoftDelete();
-        const PK = this.$state.get('PRIMARY_KEY');
-        const TEMP = 'TEMP';
+        const PK = this.$state.get("PRIMARY_KEY");
+        const TEMP = "TEMP";
         const from = new Model()
             .copyModel(this, { where: true, limit: true, orderBy: true })
             .selectRaw(PK);
-        this
-            .unset({ where: true, limit: true })
+        this.unset({ where: true, limit: true })
             .select(PK)
-            .whereSubQuery(PK, new Model().from(DB_1.DB.raw(`
-        (${from}) AS ${TEMP}`)).selectRaw(PK).toString());
+            .whereSubQuery(PK, new Model()
+            .from(DB_1.DB.raw(`(${from}) AS ${TEMP}`))
+            .selectRaw(PK));
         this.$state.set("DELETE", true);
         const result = await this._actionStatement(this._queryBuilder().remove());
         const r = Boolean(this._resultHandler(result?.$meta?.affected || false));
@@ -3709,7 +4346,6 @@ class Model extends AbstractModel_1.AbstractModel {
     async toArray(column) {
         if (column == null)
             column = "id";
-        this.selectRaw(`${this.bindColumn(column)}`);
         const sql = this._queryBuilder().select();
         const result = await this._queryStatement(sql);
         const toArray = result.map((data) => data[column]);
@@ -3745,6 +4381,7 @@ class Model extends AbstractModel_1.AbstractModel {
             return this._resultHandler(undefined);
         await this._prepareQueryPipeline();
         this.limit(1);
+        this._ensureRelationOwnerKeysSelected();
         let sql = this._queryBuilder().select();
         if (this.$state.get("RELATIONS_EXISTS"))
             sql = String(this.$relation.loadExists());
@@ -3768,6 +4405,15 @@ class Model extends AbstractModel_1.AbstractModel {
     async findOne(cb) {
         return await this.first(cb);
     }
+    /**
+     * @override
+     * @param {number} id callback function return query sql
+     * @returns {promise<Record<string,any> | null>} Record | null
+     */
+    async find(primaryKey) {
+        this.where(this.$state.get("PRIMARY_KEY"), primaryKey);
+        return await this.first();
+    }
     /**
      * @override
      * @returns {promise<object | Error>} Record | throw error
@@ -3777,6 +4423,7 @@ class Model extends AbstractModel_1.AbstractModel {
             return this._resultHandler(undefined);
         await this._prepareQueryPipeline();
         this.limit(1);
+        this._ensureRelationOwnerKeysSelected();
         let sql = this._queryBuilder().select();
         if (this.$state.get("RELATIONS_EXISTS"))
             sql = String(this.$relation.loadExists());
@@ -3805,6 +4452,7 @@ class Model extends AbstractModel_1.AbstractModel {
         if (this.$state.get("VOID"))
             return [];
         await this._prepareQueryPipeline();
+        this._ensureRelationOwnerKeysSelected();
         let sql = this._queryBuilder().select();
         if (this.$state.get("RELATIONS_EXISTS"))
             sql = String(this.$relation.loadExists());
@@ -3831,23 +4479,28 @@ class Model extends AbstractModel_1.AbstractModel {
     }
     /**
      * @override
-     * @param    {object?} paginationOptions by default page = 1 , limit = 15
-     * @property {number} paginationOptions.limit
-     * @property {number} paginationOptions.page
+     * @param    {object?}  opts by default page = 1 , limit = 15
+     * @property {number?}  opts.limit
+     * @property {number?}  opts.page
+     * @property {boolean?} opts.distinct
      * @returns  {promise<Pagination>} Pagination
      */
-    async pagination(paginationOptions) {
+    async pagination(opts) {
         let limit = 15;
         let page = 1;
-        if (paginationOptions != null) {
-            limit = this.$utils.softNumber(paginationOptions?.limit || limit);
-            page = this.$utils.softNumber(paginationOptions?.page || page);
+        if (opts?.distinct) {
+            this.distinct();
+        }
+        if (opts != null) {
+            limit = this.$utils.softNumber(opts?.limit || limit);
+            page = this.$utils.softNumber(opts?.page || page);
         }
         await this._prepareQueryPipeline();
         const offset = (page - 1) * limit;
         this.$state.set("PAGE", page);
         this.limit(limit);
         this.offset(offset);
+        this._ensureRelationOwnerKeysSelected();
         let sql = this._queryBuilder().select();
         if (this.$state.get("RELATIONS_EXISTS"))
             sql = String(this.$relation.loadExists());
@@ -3859,13 +4512,14 @@ class Model extends AbstractModel_1.AbstractModel {
     /**
      *
      * @override
-     * @param     {?object} paginationOptions by default page = 1 , limit = 15
-     * @property  {number}  paginationOptions.limit
-     * @property  {number}  paginationOptions.page
+     * @param     {?object} opts by default page = 1 , limit = 15
+     * @property  {number?} opts.limit
+     * @property  {number?} opts.page
+     * @property {boolean?} opts.distinct
      * @returns   {promise<Pagination>} Pagination
      */
-    async paginate(paginationOptions) {
-        return await this.pagination(paginationOptions);
+    async paginate(opts) {
+        return await this.pagination(opts);
     }
     /**
      * @override
@@ -3940,11 +4594,8 @@ class Model extends AbstractModel_1.AbstractModel {
      * @returns {this} this
      */
     insert(data) {
-        if (!Object.keys(data).length) {
-            throw this._assertError("This method must require at least 1 argument.");
-        }
-        this.$state.set("DATA", data);
-        if (this.$state.get('TRANSFORMS') == null) {
+        this.$state.set("DATA", this._formatedInputData(data));
+        if (this.$state.get("TRANSFORMS") == null) {
             this._queryInsertModel();
         }
         this.$state.set("SAVE", "INSERT");
@@ -3956,7 +4607,6 @@ class Model extends AbstractModel_1.AbstractModel {
      * @returns {this} this
      */
     create(data) {
-        //@ts-ignore
         return this.insert(data);
     }
     /**
@@ -3984,9 +4634,9 @@ class Model extends AbstractModel_1.AbstractModel {
                 }
             }
         }
-        this.$state.set("DATA", data);
+        this.$state.set("DATA", this._formatedInputData(data));
         this.limit(1);
-        if (this.$state.get('TRANSFORMS') == null) {
+        if (this.$state.get("TRANSFORMS") == null) {
             this._queryUpdateModel();
         }
         this.$state.set("SAVE", "UPDATE");
@@ -4017,25 +4667,25 @@ class Model extends AbstractModel_1.AbstractModel {
                 }
             }
         }
-        this.$state.set("DATA", data);
-        if (this.$state.get('TRANSFORMS') == null) {
+        this.$state.set("DATA", this._formatedInputData(data));
+        if (this.$state.get("TRANSFORMS") == null) {
             this._queryUpdateModel();
         }
         this.$state.set("SAVE", "UPDATE");
         return this;
     }
     /**
-   *
-   * @override
-   * @param {Array<{when: Record<string, string | number | boolean | null | undefined>, columns: Record<string, string | number | boolean | null | undefined>}>>} cases
-   *   An array of update cases.
-   *   - `when` is an object specifying the conditions to match records.
-   *   - `columns` is an object specifying the new values to set for the matched records.
-   *
-   * @property {Record<string,string | number | boolean | null | undefined>}  cases.when
-   * @property {Record<string,string | number | boolean | null | undefined>}  cases.columns
-   * @returns {this} this
-   */
+     *
+     * @override
+     * @param {Array<{when: Record<string, string | number | boolean | null | undefined>, columns: Record<string, string | number | boolean | null | undefined>}>>} cases
+     *   An array of update cases.
+     *   - `when` is an object specifying the conditions to match records.
+     *   - `columns` is an object specifying the new values to set for the matched records.
+     *
+     * @property {Record<string,string | number | boolean | null | undefined>}  cases.when
+     * @property {Record<string,string | number | boolean | null | undefined>}  cases.columns
+     * @returns {this} this
+     */
     updateCases(cases) {
         if (!cases.length) {
             throw this._assertError("This method must require a non-empty array.");
@@ -4122,7 +4772,7 @@ class Model extends AbstractModel_1.AbstractModel {
                 ? this.$constants("NULL")
                 : this.$utils.transfromValueHasRaw(value)}`;
         });
-        this.$state.set("DATA", columns);
+        this.$state.set("DATA", this._formatedInputData(columns));
         this.$state.set("UPDATE", keyValue);
         this.whereRaw("1");
         this.void();
@@ -4149,8 +4799,8 @@ class Model extends AbstractModel_1.AbstractModel {
                 [column]: this._updateHandler(column, value),
             };
         }
-        this.$state.set("DATA", data);
-        if (this.$state.get('TRANSFORMS') == null) {
+        this.$state.set("DATA", this._formatedInputData(data));
+        if (this.$state.get("TRANSFORMS") == null) {
             this._queryUpdateModel();
         }
         this.$state.set("SAVE", "UPDATE");
@@ -4166,8 +4816,8 @@ class Model extends AbstractModel_1.AbstractModel {
         if (!Object.keys(data).length) {
             throw this._assertError("This method must require at least 1 argument.");
         }
-        this.$state.set("DATA", data);
-        if (this.$state.get('TRANSFORMS') == null) {
+        this.$state.set("DATA", this._formatedInputData(data));
+        if (this.$state.get("TRANSFORMS") == null) {
             this._queryUpdateModel();
             this._queryInsertModel();
         }
@@ -4207,8 +4857,8 @@ class Model extends AbstractModel_1.AbstractModel {
         if (!Object.keys(data).length) {
             throw this._assertError("This method must require at least 1 argument.");
         }
-        this.$state.set("DATA", data);
-        if (this.$state.get('TRANSFORMS') == null) {
+        this.$state.set("DATA", this._formatedInputData(data));
+        if (this.$state.get("TRANSFORMS") == null) {
             this._queryInsertModel();
         }
         this.$state.set("SAVE", "INSERT_OR_SELECT");
@@ -4232,8 +4882,8 @@ class Model extends AbstractModel_1.AbstractModel {
         if (!Object.keys(data).length) {
             throw this._assertError("This method must require at least 1 argument.");
         }
-        this.$state.set("DATA", data);
-        if (this.$state.get('TRANSFORMS') == null) {
+        this.$state.set("DATA", this._formatedInputData(data));
+        if (this.$state.get("TRANSFORMS") == null) {
             this._queryInsertModel();
         }
         this.$state.set("SAVE", "INSERT_NOT_EXISTS");
@@ -4257,8 +4907,8 @@ class Model extends AbstractModel_1.AbstractModel {
         if (!Array.isArray(data) || !data.length) {
             throw this._assertError("This method must require a non-empty array.");
         }
-        this.$state.set("DATA", data);
-        if (this.$state.get('TRANSFORMS') == null) {
+        this.$state.set("DATA", this._formatedInputData(data));
+        if (this.$state.get("TRANSFORMS") == null) {
             this._queryInsertMultipleModel();
         }
         this.$state.set("SAVE", "INSERT_MULTIPLE");
@@ -4271,7 +4921,6 @@ class Model extends AbstractModel_1.AbstractModel {
      * @returns {this} this
      */
     createMany(data) {
-        //@ts-ignore
         return this.createMultiple(data);
     }
     /**
@@ -4281,7 +4930,6 @@ class Model extends AbstractModel_1.AbstractModel {
      * @returns {this} this
      */
     insertMultiple(data) {
-        //@ts-ignore
         return this.createMultiple(data);
     }
     /**
@@ -4291,7 +4939,6 @@ class Model extends AbstractModel_1.AbstractModel {
      * @returns {this} this
      */
     insertMany(data) {
-        //@ts-ignore
         return this.createMultiple(data);
     }
     /**
@@ -4385,7 +5032,9 @@ class Model extends AbstractModel_1.AbstractModel {
             for (const { Field: field, Type: type } of fields) {
                 if (passed(field))
                     continue;
-                const blueprint = this._getBlueprintByColumn(field, { schema: schemaModel });
+                const blueprint = this._getBlueprintByColumn(field, {
+                    schema: schemaModel,
+                });
                 if (blueprint?.isVirtual)
                     continue;
                 const value = field === uuid
@@ -4409,9 +5058,7 @@ class Model extends AbstractModel_1.AbstractModel {
         const debug = this.$state.get("DEBUG");
         const queue = [...chunkedData];
         const runNext = async () => {
-            const batch = Array
-                .from({ length: 3 }, () => queue.shift())
-                .filter(Boolean);
+            const batch = Array.from({ length: 3 }, () => queue.shift()).filter(Boolean);
             if (!batch.length)
                 return;
             await Promise.all(batch.map((data) => {
@@ -4419,13 +5066,14 @@ class Model extends AbstractModel_1.AbstractModel {
                     .from(table)
                     .debug(debug)
                     .createMultiple(data)
+                    .bind(this.$pool.get())
                     .void()
                     .save();
             }));
             await runNext();
         };
         const promises = Array.from({ length: 5 }, () => () => runNext());
-        await Promise.all(promises.map(v => v()));
+        await Promise.all(promises.map((v) => v()));
         return;
     }
     /**
@@ -4826,7 +5474,7 @@ class Model extends AbstractModel_1.AbstractModel {
             case this.$constants("PATTERN").default: {
                 return column;
             }
-            case this.$constants("PATTERN").snakeCase: {
+            case this.$constants("PATTERN").snake_case: {
                 return column.replace(/([A-Z])/g, (str) => `_${str.toLowerCase()}`);
             }
             case this.$constants("PATTERN").camelCase: {
@@ -4861,7 +5509,7 @@ class Model extends AbstractModel_1.AbstractModel {
             this.bindColumn(`${this.getTableName()}.${deletedAt}`),
             this.$constants("IS_NULL"),
         ].join(" ");
-        if (!wheres.some((where) => where.includes(softDeleteIsNull))) {
+        if (!wheres.some((v) => v.column?.includes(softDeleteIsNull))) {
             this.whereNull(deletedAt);
             return this;
         }
@@ -4873,9 +5521,23 @@ class Model extends AbstractModel_1.AbstractModel {
         if (this.$state.get("EXCEPTS")?.length) {
             pipeline.push(async () => this.select(...(await this.exceptColumns())));
         }
-        await Promise.all(pipeline.map(fn => fn())).catch((err) => console.log(err));
+        await Promise.all(pipeline.map((fn) => fn())).catch((err) => console.log(err));
         return;
     }
+    _ensureRelationOwnerKeysSelected() {
+        const relations = this.$state.get("RELATIONS");
+        const relationship = this.$constants("RELATIONSHIP");
+        const ownerKeyRelations = relations.filter((r) => {
+            return (r.relation === relationship.hasMany ||
+                r.relation === relationship.hasOne);
+        });
+        if (!ownerKeyRelations.length)
+            return;
+        const ownerKeys = new Set(ownerKeyRelations.map((r) => {
+            return r.localKey ?? this.$state.get("PRIMARY_KEY");
+        }));
+        this.addSelect(...ownerKeys);
+    }
     _handleGlobalScope() {
         if (!this.$state.get("GLOBAL_SCOPE"))
             return this;
@@ -4918,7 +5580,7 @@ class Model extends AbstractModel_1.AbstractModel {
                 const sql = schemaColumn.sql.select;
                 if (sql == null)
                     continue;
-                if (sql.toLowerCase().includes(" as ")) {
+                if (sql.toLowerCase().includes(` ${this.$constants("AS")} `)) {
                     columns.push(sql);
                     continue;
                 }
@@ -4929,7 +5591,7 @@ class Model extends AbstractModel_1.AbstractModel {
                 columns.push(this.bindColumn(key));
                 continue;
             }
-            columns.push(this.bindColumn(schemaColumn.column, false));
+            columns.push(this.bindColumn(schemaColumn.column, { pattern: false }));
         }
         if (!columns.length)
             return this;
@@ -4945,9 +5607,7 @@ class Model extends AbstractModel_1.AbstractModel {
      * generate sql statements
      * @override
      */
-    _queryBuilder({ onFormat = false } = {}) {
-        if (onFormat)
-            return this._buildQueryStatement();
+    _queryBuilder() {
         this._handleSelect();
         this._handleSoftDelete();
         return this._buildQueryStatement();
@@ -4968,7 +5628,7 @@ class Model extends AbstractModel_1.AbstractModel {
                     data = callback;
             }
         }
-        this.$state.set("DATA", data);
+        this.$state.set("DATA", this._formatedInputData(data));
         return;
     }
     async _runAfter(action, data) {
@@ -5090,7 +5750,7 @@ class Model extends AbstractModel_1.AbstractModel {
         if (findCache == null)
             return;
         if (this.$state.get("DEBUG")) {
-            this.$utils.consoleCache(JSON.stringify({
+            this.$utils.consoleCache({
                 driver: this.$cache.provider(),
                 key: cache.key,
                 expires: cache.expires,
@@ -5099,7 +5759,7 @@ class Model extends AbstractModel_1.AbstractModel {
                     this.$utils.typeOf(findCache) === "string"
                     ? findCache.length
                     : undefined,
-            }));
+            });
             const endTime = +new Date();
             this.$utils.consoleExec(startTime, endTime);
         }
@@ -5136,8 +5796,8 @@ class Model extends AbstractModel_1.AbstractModel {
             this._returnEmpty(type, result, message, options));
     }
     async _pagination(data) {
-        const currentPage = +this.$state.get("PAGE");
-        const limit = Number(this.$state.get("LIMIT"));
+        const currentPage = this.$state.get("PAGE") ?? 0;
+        const limit = Number(this.$state.get("LIMIT") ?? 0);
         if (limit < 1) {
             throw this._assertError("This pagination needed limit minimun less 1 for limit");
         }
@@ -5145,7 +5805,6 @@ class Model extends AbstractModel_1.AbstractModel {
             .copyModel(this, { where: true, join: true })
             .bind(this.$pool.get())
             .debug(this.$state.get("DEBUG"))
-            .unset({ alias: true })
             .count(this.$state.get("PRIMARY_KEY"));
         let lastPage = Math.ceil(total / limit) || 0;
         lastPage = lastPage > 1 ? lastPage : 1;
@@ -5160,15 +5819,21 @@ class Model extends AbstractModel_1.AbstractModel {
             last_page: lastPage,
             next_page: nextPage,
             prev_page: prevPage,
+            page: {
+                prev: prevPage,
+                next: nextPage,
+                current: currentPage,
+                last: lastPage,
+            },
         };
         const pattern = this.$state.get("PATTERN");
-        if (pattern === 'snake_case') {
+        if (pattern === this.$constants("PATTERN").snake_case) {
             return this.$utils.snakeCase(this._resultHandler({
                 meta,
                 data,
             }));
         }
-        if (pattern === 'camelCase') {
+        if (pattern === this.$constants("PATTERN").camelCase) {
             return this.$utils.camelCase(this._resultHandler({
                 meta,
                 data,
@@ -5215,6 +5880,12 @@ class Model extends AbstractModel_1.AbstractModel {
                         last_page: 0,
                         next_page: 0,
                         prev_page: 0,
+                        page: {
+                            prev: 0,
+                            next: 0,
+                            current: Number(this.$state.get("PAGE")),
+                            last: 0,
+                        },
                     },
                     data: [],
                 };
@@ -5223,14 +5894,14 @@ class Model extends AbstractModel_1.AbstractModel {
             default:
                 throw this._assertError("Missing method first get or pagination");
         }
-        if (this.$state.get('PATTERN') === 'snake_case') {
+        if (this.$state.get("PATTERN") === this.$constants("PATTERN").snake_case) {
             const empty = this.$utils.snakeCase(this._resultHandler(emptyData));
             await this.$utils.hookHandle(this.$state.get("HOOKS"), empty);
             await this._observer(empty, "selected");
             return empty;
         }
-        if (this.$state.get('PATTERN') === 'camelCase') {
-            const empty = this.$utils.snakeCase(this._resultHandler(emptyData));
+        if (this.$state.get("PATTERN") === this.$constants("PATTERN").camelCase) {
+            const empty = this.$utils.camelCase(this._resultHandler(emptyData));
             await this.$utils.hookHandle(this.$state.get("HOOKS"), empty);
             await this._observer(empty, "selected");
             return empty;
@@ -5266,11 +5937,11 @@ class Model extends AbstractModel_1.AbstractModel {
                 throw this._assertError("Missing method first get or pagination");
             }
         }
-        if (this.$state.get('TRANSFORMS') != null) {
+        if (this.$state.get("TRANSFORMS") != null) {
             await this.$utils.applyTransforms({
                 result,
-                transforms: this.$state.get('TRANSFORMS'),
-                action: 'from'
+                transforms: this.$state.get("TRANSFORMS"),
+                action: "from",
             });
         }
         await this.$utils.hookHandle(this.$state.get("HOOKS"), result);
@@ -5290,11 +5961,11 @@ class Model extends AbstractModel_1.AbstractModel {
                     : this.$utils.transfromDateToDateString(objects[updatedAt]),
             };
         }
-        if (this.$state.get('TRANSFORMS') != null) {
+        if (this.$state.get("TRANSFORMS") != null) {
             await this.$utils.applyTransforms({
                 result: objects,
-                transforms: this.$state.get('TRANSFORMS'),
-                action: 'to'
+                transforms: this.$state.get("TRANSFORMS"),
+                action: "to",
             });
         }
         const keyValue = Object.entries(objects).map(([column, value]) => {
@@ -5327,11 +5998,11 @@ class Model extends AbstractModel_1.AbstractModel {
                     : this.$utils.transfromDateToDateString(data[updatedAt]),
             };
         }
-        if (this.$state.get('TRANSFORMS') != null) {
+        if (this.$state.get("TRANSFORMS") != null) {
             await this.$utils.applyTransforms({
                 result: data,
-                transforms: this.$state.get('TRANSFORMS'),
-                action: 'to'
+                transforms: this.$state.get("TRANSFORMS"),
+                action: "to",
             });
         }
         const hasUUID = data.hasOwnProperty(this.$state.get("UUID_FORMAT"));
@@ -5358,7 +6029,7 @@ class Model extends AbstractModel_1.AbstractModel {
         });
         this.$state.set("INSERT", {
             columns,
-            values: [values.join(', ')]
+            values: [values.join(", ")],
         });
         return;
     }
@@ -5385,11 +6056,11 @@ class Model extends AbstractModel_1.AbstractModel {
                 };
                 columns = [...columns, `\`${createdAt}\``, `\`${updatedAt}\``];
             }
-            if (this.$state.get('TRANSFORMS') != null) {
+            if (this.$state.get("TRANSFORMS") != null) {
                 await this.$utils.applyTransforms({
                     result: objects,
-                    transforms: this.$state.get('TRANSFORMS'),
-                    action: 'to'
+                    transforms: this.$state.get("TRANSFORMS"),
+                    action: "to",
                 });
             }
             const hasUUID = objects.hasOwnProperty(this.$state.get("UUID_FORMAT"));
@@ -5417,13 +6088,13 @@ class Model extends AbstractModel_1.AbstractModel {
             values = [...values, `${v.join(",")}`];
             newData.push(objects);
         }
-        this.$state.set("DATA", newData);
+        this.$state.set("DATA", this._formatedInputData(newData));
         columns = [
             ...new Set(columns.map((c) => `\`${this._valuePattern(c).replace(/\`/g, "")}\``)),
         ];
         this.$state.set("INSERT", {
             columns,
-            values
+            values,
         });
         return;
     }
@@ -5442,7 +6113,7 @@ class Model extends AbstractModel_1.AbstractModel {
         if (check)
             return this._resultHandler(null);
         await this._runBefore("insert");
-        if (this.$state.get('TRANSFORMS') != null) {
+        if (this.$state.get("TRANSFORMS") != null) {
             await this._queryInsertModel();
         }
         await this._validateSchema(this.$state.get("DATA"), "insert");
@@ -5452,7 +6123,7 @@ class Model extends AbstractModel_1.AbstractModel {
         await this.$utils.wait(this.$state.get("AFTER_SAVE"));
         let resultData = await new Model()
             .copyModel(this, { select: true, relations: true })
-            .whereIn("id", result.$meta.insertIds)
+            .whereIn(this.$state.get('PRIMARY_KEY'), result.$meta.insertIds)
             .bind(this.$pool.get())
             .debug(this.$state.get("DEBUG"))
             .first();
@@ -5460,7 +6131,7 @@ class Model extends AbstractModel_1.AbstractModel {
             await this.$utils.wait(500);
             resultData = await new Model()
                 .copyModel(this, { select: true, relations: true })
-                .whereIn("id", result.$meta.insertIds)
+                .whereIn(this.$state.get('PRIMARY_KEY'), result.$meta.insertIds)
                 .bind(this.$pool.get())
                 .debug(this.$state.get("DEBUG"))
                 .first();
@@ -5469,7 +6140,7 @@ class Model extends AbstractModel_1.AbstractModel {
     }
     async _insertModel() {
         await this._runBefore("insert");
-        if (this.$state.get('TRANSFORMS') != null) {
+        if (this.$state.get("TRANSFORMS") != null) {
             await this._queryInsertModel();
         }
         await this._validateSchema(this.$state.get("DATA"), "insert");
@@ -5481,7 +6152,7 @@ class Model extends AbstractModel_1.AbstractModel {
         await this.$utils.wait(this.$state.get("AFTER_SAVE"));
         let resultData = await new Model()
             .copyModel(this, { select: true, relations: true })
-            .whereIn("id", result.$meta.insertIds)
+            .whereIn(this.$state.get('PRIMARY_KEY'), result.$meta.insertIds)
             .bind(this.$pool.get())
             .debug(this.$state.get("DEBUG"))
             .first();
@@ -5489,7 +6160,7 @@ class Model extends AbstractModel_1.AbstractModel {
             await this.$utils.wait(1000);
             resultData = await new Model()
                 .copyModel(this, { select: true, relations: true })
-                .whereIn("id", result.$meta.insertIds)
+                .whereIn(this.$state.get('PRIMARY_KEY'), result.$meta.insertIds)
                 .bind(this.$pool.get())
                 .debug(this.$state.get("DEBUG"))
                 .first();
@@ -5501,7 +6172,7 @@ class Model extends AbstractModel_1.AbstractModel {
     async _insertMultipleModel() {
         const data = this.$state.get("DATA") ?? [];
         await this._runBefore("insert");
-        if (this.$state.get('TRANSFORMS') != null) {
+        if (this.$state.get("TRANSFORMS") != null) {
             await this._queryInsertMultipleModel();
         }
         for (const v of data) {
@@ -5542,7 +6213,7 @@ class Model extends AbstractModel_1.AbstractModel {
         switch (check) {
             case false: {
                 await this._runBefore("insert");
-                if (this.$state.get('TRANSFORMS') != null) {
+                if (this.$state.get("TRANSFORMS") != null) {
                     await this._queryInsertModel();
                 }
                 await this._validateSchema(this.$state.get("DATA"), "insert");
@@ -5553,7 +6224,7 @@ class Model extends AbstractModel_1.AbstractModel {
                 let data = await new Model()
                     .copyModel(this, { select: true })
                     .bind(this.$pool.get())
-                    .whereIn("id", result.$meta.insertIds)
+                    .whereIn(this.$state.get('PRIMARY_KEY'), result.$meta.insertIds)
                     .debug(this.$state.get("DEBUG"))
                     .first();
                 if (data == null) {
@@ -5561,7 +6232,7 @@ class Model extends AbstractModel_1.AbstractModel {
                     data = await new Model()
                         .copyModel(this, { select: true })
                         .bind(this.$pool.get())
-                        .whereIn("id", result.$meta.insertIds)
+                        .whereIn(this.$state.get('PRIMARY_KEY'), result.$meta.insertIds)
                         .debug(this.$state.get("DEBUG"))
                         .first();
                 }
@@ -5573,7 +6244,7 @@ class Model extends AbstractModel_1.AbstractModel {
             }
             case true: {
                 await this._runBefore("update");
-                if (this.$state.get('TRANSFORMS') != null) {
+                if (this.$state.get("TRANSFORMS") != null) {
                     await this._queryUpdateModel();
                 }
                 await this._validateSchema(this.$state.get("DATA"), "update");
@@ -5612,7 +6283,7 @@ class Model extends AbstractModel_1.AbstractModel {
         switch (check) {
             case false: {
                 await this._runBefore("insert");
-                if (this.$state.get('TRANSFORMS') != null) {
+                if (this.$state.get("TRANSFORMS") != null) {
                     await this._queryInsertModel();
                 }
                 await this._validateSchema(this.$state.get("DATA"), "insert");
@@ -5623,7 +6294,7 @@ class Model extends AbstractModel_1.AbstractModel {
                 let data = await new Model()
                     .copyModel(this, { select: true })
                     .bind(this.$pool.get())
-                    .whereIn("id", result.$meta.insertIds)
+                    .whereIn(this.$state.get('PRIMARY_KEY'), result.$meta.insertIds)
                     .debug(this.$state.get("DEBUG"))
                     .first();
                 if (data == null) {
@@ -5631,7 +6302,7 @@ class Model extends AbstractModel_1.AbstractModel {
                     data = await new Model()
                         .copyModel(this, { select: true })
                         .bind(this.$pool.get())
-                        .whereIn("id", result.$meta.insertIds)
+                        .whereIn(this.$state.get('PRIMARY_KEY'), result.$meta.insertIds)
                         .debug(this.$state.get("DEBUG"))
                         .first();
                 }
@@ -5670,7 +6341,7 @@ class Model extends AbstractModel_1.AbstractModel {
     async _updateModel() {
         this._guardWhereCondition();
         await this._runBefore("update");
-        if (this.$state.get('TRANSFORMS') != null) {
+        if (this.$state.get("TRANSFORMS") != null) {
             await this._queryUpdateModel();
         }
         await this._validateSchema(this.$state.get("DATA"), "update");
@@ -5709,6 +6380,10 @@ class Model extends AbstractModel_1.AbstractModel {
             throw new Error(message);
         return;
     }
+    disabledRetry() {
+        this.$state.set("RETRY", 3);
+        return this;
+    }
     async _checkSchemaOrNextError(e, retry = 1, originError) {
         const throwError = originError == null ? e : originError;
         try {
@@ -5719,12 +6394,19 @@ class Model extends AbstractModel_1.AbstractModel {
                 return this._stoppedRetry(throwError);
             if (!(e instanceof Error))
                 return this._stoppedRetry(throwError);
-            await this.sync({ force: true });
+            await new Promise((r) => setTimeout(r, 1000));
+            await new Model()
+                .copyModel(this)
+                .disabledRetry()
+                .debug(this.$state.get('DEBUG'))
+                .sync({ force: true }).catch(() => null);
+            this.$state.set("RETRY", retry + 1);
         }
         catch (e) {
             if (retry >= 3) {
                 throw throwError;
             }
+            this.$state.set("RETRY", retry + 1);
             await this._checkSchemaOrNextError(e, retry + 1, originError);
         }
     }
@@ -5749,20 +6431,26 @@ class Model extends AbstractModel_1.AbstractModel {
         const uuidIsEnabled = Reflect.getMetadata(Decorator_1.REFLECT_META.UUID.enabled, this.constructor) || null;
         if (uuidIsEnabled) {
             this.$uuid = true;
-            this.$uuidColumn = Reflect.getMetadata(Decorator_1.REFLECT_META.UUID.column, this.constructor) || null;
+            this.$uuidColumn =
+                Reflect.getMetadata(Decorator_1.REFLECT_META.UUID.column, this.constructor) || null;
         }
-        const timestamp = Reflect.getMetadata(Decorator_1.REFLECT_META.TIMESTAMP.enabled, this.constructor) || null;
+        const timestamp = Reflect.getMetadata(Decorator_1.REFLECT_META.TIMESTAMP.enabled, this.constructor) ||
+            null;
         if (timestamp) {
             this.$timestamp = true;
-            this.$timestampColumns = Reflect.getMetadata(Decorator_1.REFLECT_META.TIMESTAMP.columns, this.constructor) || null;
+            this.$timestampColumns =
+                Reflect.getMetadata(Decorator_1.REFLECT_META.TIMESTAMP.columns, this.constructor) ||
+                    null;
         }
         const pattern = Reflect.getMetadata(Decorator_1.REFLECT_META.PATTERN, this.constructor) || null;
         if (pattern)
             this.$pattern = pattern;
-        const softDelete = Reflect.getMetadata(Decorator_1.REFLECT_META.SOFT_DELETE.enabled, this.constructor) || null;
+        const softDelete = Reflect.getMetadata(Decorator_1.REFLECT_META.SOFT_DELETE.enabled, this.constructor) ||
+            null;
         if (softDelete) {
             this.$softDelete = true;
-            this.$softDeleteColumn = Reflect.getMetadata(Decorator_1.REFLECT_META.SOFT_DELETE.columns, this.constructor) || null;
+            this.$softDeleteColumn =
+                Reflect.getMetadata(Decorator_1.REFLECT_META.SOFT_DELETE.columns, this.constructor) || null;
         }
         const schema = Reflect.getMetadata(Decorator_1.REFLECT_META.SCHEMA, this) || null;
         if (schema)
@@ -5834,27 +6522,27 @@ class Model extends AbstractModel_1.AbstractModel {
             this.useHooks(hooks);
         const beforeInserts = Reflect.getMetadata(Decorator_1.REFLECT_META.BEFORE.INSERT, this) || [];
         if (beforeInserts.length) {
-            this.useLifecycle('beforeInsert', beforeInserts);
+            this.useLifecycle("beforeInsert", beforeInserts);
         }
         const afterInserts = Reflect.getMetadata(Decorator_1.REFLECT_META.AFTER.INSERT, this) || [];
         if (afterInserts.length) {
-            this.useLifecycle('afterInsert', afterInserts);
+            this.useLifecycle("afterInsert", afterInserts);
         }
         const beforeUpdates = Reflect.getMetadata(Decorator_1.REFLECT_META.BEFORE.UPDATE, this) || [];
         if (beforeUpdates.length) {
-            this.useLifecycle('beforeUpdate', beforeUpdates);
+            this.useLifecycle("beforeUpdate", beforeUpdates);
         }
         const afterUpdates = Reflect.getMetadata(Decorator_1.REFLECT_META.AFTER.UPDATE, this) || [];
         if (afterUpdates.length) {
-            this.useLifecycle('afterUpdate', afterUpdates);
+            this.useLifecycle("afterUpdate", afterUpdates);
         }
         const beforeRemoves = Reflect.getMetadata(Decorator_1.REFLECT_META.BEFORE.REMOVE, this) || [];
         if (beforeRemoves.length) {
-            this.useLifecycle('beforeRemove', beforeRemoves);
+            this.useLifecycle("beforeRemove", beforeRemoves);
         }
         const afterRemoves = Reflect.getMetadata(Decorator_1.REFLECT_META.AFTER.REMOVE, this) || [];
         if (afterRemoves.length) {
-            this.useLifecycle('afterRemove', afterRemoves);
+            this.useLifecycle("afterRemove", afterRemoves);
         }
         return this;
     }
@@ -5869,7 +6557,7 @@ class Model extends AbstractModel_1.AbstractModel {
                 this.bindColumn(`${this.getTableName()}.${deletedAt}`),
                 this.$constants("IS_NULL"),
             ].join(" ");
-            if (wheres.some((where) => where.includes(softDeleteIsNull))) {
+            if (wheres.some((v) => v.column?.includes(softDeleteIsNull))) {
                 throw this._assertError(`The statement is not allowed to use the '${deletedAt}' column as a condition for any action`);
             }
         }
@@ -5883,7 +6571,7 @@ class Model extends AbstractModel_1.AbstractModel {
             return false;
         }
     }
-    _getBlueprintByColumn(column, { schema } = {}) {
+    _getBlueprintByColumn(column, { schema, } = {}) {
         schema = schema ?? this.getSchemaModel();
         if (!schema)
             return null;
@@ -5893,8 +6581,16 @@ class Model extends AbstractModel_1.AbstractModel {
         return blueprint;
     }
     _handleJoinModel(m1, m2) {
-        let model1 = typeof m1 === "object" ? new m1.model() : new m1();
-        let model2 = typeof m2 === "object" ? new m2.model() : new m2();
+        let model1 = typeof m1 === "object"
+            ? m1 instanceof Model
+                ? m1
+                : new m1.model()
+            : new m1();
+        let model2 = typeof m2 === "object"
+            ? m2 instanceof Model
+                ? m2
+                : new m2.model()
+            : new m2();
         let localKey = typeof m1 === "object"
             ? m1.key != null && m1.key !== ""
                 ? String(m1.key)
@@ -5906,18 +6602,30 @@ class Model extends AbstractModel_1.AbstractModel {
                 : ""
             : "";
         let alias1 = typeof m1 === "object"
-            ? m1.alias != null && m1.alias !== ""
-                ? m1.alias
-                : ""
+            ? m1 instanceof Model
+                ? model1.$state.get("ALIAS") ?? ""
+                : m1.alias != null && m1.alias !== ""
+                    ? m1.alias
+                    : ""
             : "";
         let alias2 = typeof m2 === "object"
-            ? m2.alias != null && m2.alias !== ""
-                ? m2.alias
-                : ""
+            ? m2 instanceof Model
+                ? model2.$state.get("ALIAS") ?? ""
+                : m2.alias != null && m2.alias !== ""
+                    ? m2.alias
+                    : ""
             : "";
         if (alias1 !== "") {
             if (model1["$state"].get("MODEL_NAME") === this["$state"].get("MODEL_NAME")) {
                 this.alias(alias1);
+                const selecteds = this.$state.get("SELECT");
+                const formated = [];
+                for (const selected of selecteds) {
+                    const table = this.getTableName();
+                    formated.push(selected.replace(table, alias1));
+                }
+                if (formated.length)
+                    this.$state.set("SELECT", formated);
             }
             model1.alias(alias1);
         }
@@ -5942,10 +6650,32 @@ class Model extends AbstractModel_1.AbstractModel {
             foreignKey,
         };
     }
+    _formatedInputData(data) {
+        const schema = this.getSchemaModel();
+        if (!schema)
+            return data;
+        if (data == null)
+            return data;
+        const formatObject = (obj) => {
+            if (obj === null || typeof obj !== 'object')
+                return obj;
+            const result = {};
+            for (const key of Object.keys(schema)) {
+                if (key in obj) {
+                    result[key] = obj[key];
+                }
+            }
+            return result;
+        };
+        if (Array.isArray(data)) {
+            return data.map(item => formatObject(item));
+        }
+        return formatObject(data);
+    }
     _initialModel() {
         this.$cache = Cache_1.Cache;
         this.$state = new StateManager_1.StateManager("model");
-        this.meta("MAIN");
+        this.metaTag("MAIN");
         this._makeTableName();
         this.$relation = new RelationManager_1.RelationManager(this);
         if (globalSettings.debug)