tspace-mysql 1.9.1 → 1.9.2

package/dist/lib/core/Model.js

@@ -48,7 +48,8 @@ const Cache_1 = require("./Cache");
 const JoinModel_1 = require("./JoinModel");
 const constants_1 = require("../constants");
 const Decorator_1 = require("./Decorator");
-const Repository_1 = __importDefault(require("./Repository"));
+const Join_1 = require("./Join");
+const Repository_1 = require("./Repository");
 let globalSettings = {
     softDelete: false,
     debug: false,
@@ -213,7 +214,7 @@ class Model extends AbstractModel_1.AbstractModel {
      *
      */
     static async find(primaryKey, options = {}) {
-        return await (0, Repository_1.default)(this).find(primaryKey, options);
+        return await (0, Repository_1.Repository)(this).find(primaryKey, options);
     }
     /**
      *
@@ -253,7 +254,7 @@ class Model extends AbstractModel_1.AbstractModel {
      *
      */
     static async findOne(options = {}) {
-        return await (0, Repository_1.default)(this).findOne(options);
+        return await (0, Repository_1.Repository)(this).findOne(options);
     }
     /**
      *
@@ -293,7 +294,7 @@ class Model extends AbstractModel_1.AbstractModel {
      *
      */
     static async findMany(options = {}) {
-        return await (0, Repository_1.default)(this).findMany(options);
+        return await (0, Repository_1.Repository)(this).findMany(options);
     }
     /**
      *
@@ -336,7 +337,7 @@ class Model extends AbstractModel_1.AbstractModel {
      *   })
      */
     static async paginate(options = {}) {
-        return await (0, Repository_1.default)(this).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.
@@ -371,7 +372,7 @@ class Model extends AbstractModel_1.AbstractModel {
      *
      */
     static async exists(options) {
-        return await (0, Repository_1.default)(this).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.
@@ -406,7 +407,7 @@ class Model extends AbstractModel_1.AbstractModel {
      *
      */
     static toQuery(options) {
-        return (0, Repository_1.default)(this).toString(options);
+        return (0, Repository_1.Repository)(this).toString(options);
     }
     /**
      * The 'create' method is used to insert a new record into a database table associated.
@@ -419,7 +420,7 @@ class Model extends AbstractModel_1.AbstractModel {
      * @return {promise<T.Result<M>>}
      */
     static async create(options) {
-        return (0, Repository_1.default)(this).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.
@@ -432,7 +433,7 @@ class Model extends AbstractModel_1.AbstractModel {
      * @return {promise<TS[]>}
      */
     static async createMany(options) {
-        return (0, Repository_1.default)(this).createMany(options);
+        return (0, Repository_1.Repository)(this).createMany(options);
     }
     /**
      *
@@ -447,7 +448,8 @@ class Model extends AbstractModel_1.AbstractModel {
      * @return {promise<NR extends true ? undefined : T.Result<M>[]>}
      */
     static async createOrUpdate(options) {
-        return (0, Repository_1.default)(this).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.
@@ -463,7 +465,7 @@ class Model extends AbstractModel_1.AbstractModel {
      * @return {promise<T | null>}
      */
     static async createNotExists(options) {
-        return (0, Repository_1.default)(this).createNotExists(options);
+        return (0, Repository_1.Repository)(this).createNotExists(options);
     }
     /**
      *
@@ -478,7 +480,7 @@ class Model extends AbstractModel_1.AbstractModel {
      * @return {promise<T.Result<M>>}
      */
     static async createOrSelect(options) {
-        return (0, Repository_1.default)(this).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.
@@ -494,7 +496,7 @@ class Model extends AbstractModel_1.AbstractModel {
      * @return {promise< NR extends true ? undefined : T.Result<M> | null>}
      */
     static async update(options) {
-        return (0, Repository_1.default)(this).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.
@@ -510,7 +512,7 @@ class Model extends AbstractModel_1.AbstractModel {
      * @return {promise<T.Result<M>[]>}
      */
     static async updateMany(options) {
-        return (0, Repository_1.default)(this).updateMany(options);
+        return (0, Repository_1.Repository)(this).updateMany(options);
     }
     /**
      * The 'cache' method is used get the functions from the Cache
@@ -549,6 +551,91 @@ class Model extends AbstractModel_1.AbstractModel {
             },
         };
     }
+    /**
+     * 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.
      *  @example
@@ -1300,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;
     }
@@ -1376,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);
@@ -1551,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 === ""
@@ -1566,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, "")}\`.*`;
         }
@@ -1766,7 +1859,6 @@ class Model extends AbstractModel_1.AbstractModel {
      */
     async _queryStatement(sql, { retry = false } = {}) {
         try {
-            sql = this._queryBuilder().format([sql]);
             const getResults = async (sql) => {
                 if (this.$state.get("DEBUG")) {
                     const startTime = +new Date();
@@ -1812,7 +1904,6 @@ class Model extends AbstractModel_1.AbstractModel {
      */
     async _actionStatement(sql, { retry = false } = {}) {
         try {
-            sql = this._queryBuilder().format([sql]);
             const getResults = async (sql) => {
                 if (this.$state.get("DEBUG")) {
                     const startTime = +new Date();
@@ -2292,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) {
@@ -2416,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.
      *
@@ -2564,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
      *
@@ -2702,7 +2936,7 @@ class Model extends AbstractModel_1.AbstractModel {
             : `${deletedAt} = NULL`;
         this.$state.set("UPDATE", [`${query}`]);
         this.$state.set("SAVE", "UPDATE");
-        return (await this.save());
+        return (await this.bind(this.$pool.get()).save());
     }
     /**
      *
@@ -3644,13 +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;
     }
     /**
@@ -3661,13 +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;
     }
     /**
@@ -3678,13 +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;
     }
     /**
@@ -3694,13 +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;
         }
-        this._handleJoin("CROSS_JOIN", localKey, referenceKey);
+        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.crossJoinModel(localKey, referenceKey);
         return this;
     }
     /**
@@ -3746,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")) {
@@ -3810,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")) {
@@ -3856,18 +4122,19 @@ class Model extends AbstractModel_1.AbstractModel {
     /**
      *
      * @override
-     * @param {string=} column [column=id]
+     * @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 === "*"
-            ? "*"
-            : distinct
-                ? `${this.$constants("DISTINCT")} ${this.bindColumn(column)}`
-                : `${this.bindColumn(column)}`;
+        column =
+            column === "*"
+                ? "*"
+                : distinct
+                    ? `${this.$constants("DISTINCT")} ${this.bindColumn(column)}`
+                    : `${this.bindColumn(column)}`;
         this.selectRaw([
             `${this.$constants("COUNT")}(${column})`,
             `${this.$constants("AS")}`,
@@ -3880,7 +4147,7 @@ class Model extends AbstractModel_1.AbstractModel {
     /**
      *
      * @override
-     * @param {string=} column [column=id]
+     * @param {string=} c [column=id]
      * @returns {promise<number>}
      */
     async avg(c) {
@@ -3899,7 +4166,7 @@ class Model extends AbstractModel_1.AbstractModel {
     /**
      *
      * @override
-     * @param {string=} column [column=id]
+     * @param {string=} c [column=id]
      * @returns {promise<number>}
      */
     async sum(c) {
@@ -3918,7 +4185,7 @@ class Model extends AbstractModel_1.AbstractModel {
     /**
      *
      * @override
-     * @param {string=} column [column=id]
+     * @param {string=} c [column=id]
      * @returns {promise<number>}
      */
     async max(c) {
@@ -4032,10 +4299,8 @@ class Model extends AbstractModel_1.AbstractModel {
         this.unset({ where: true, limit: true })
             .select(PK)
             .whereSubQuery(PK, new Model()
-            .from(DB_1.DB.raw(`
-        (${from}) AS ${TEMP}`))
-            .selectRaw(PK)
-            .toString());
+            .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));
@@ -4081,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]);
@@ -4215,17 +4479,21 @@ 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;
@@ -4244,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
@@ -4325,9 +4594,6 @@ 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", this._formatedInputData(data));
         if (this.$state.get("TRANSFORMS") == null) {
             this._queryInsertModel();
@@ -4800,6 +5066,7 @@ class Model extends AbstractModel_1.AbstractModel {
                     .from(table)
                     .debug(debug)
                     .createMultiple(data)
+                    .bind(this.$pool.get())
                     .void()
                     .save();
             }));
@@ -5324,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;
@@ -5538,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;
@@ -6315,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)
@@ -6328,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);
         }
@@ -6389,7 +6675,7 @@ class Model extends AbstractModel_1.AbstractModel {
     _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)