tspace-mysql 1.4.7 → 1.4.9

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

@@ -1,5 +1,5 @@
-import { AbstractDB } from './Abstract/AbstractDB';
-import { Connection, ConnectionOptions, ConnectionTransaction } from './Interface';
+import { AbstractDB } from './Abstracts/AbstractDB';
+import { Connection, ConnectionOptions, ConnectionTransaction } from '../Interface';
 /**
  * 'DB' class is a component of the database system
  * @param {string?} table table name
@@ -95,6 +95,46 @@ declare class DB extends AbstractDB {
      * @return {string} string
      */
     static generateUUID(): string;
+    /**
+     * The 'snakeCase' methid is used to covert value to snakeCase pattern.
+     * @return {string} string
+     */
+    snakeCase(value: string): string;
+    /**
+     * The 'snakeCase' methid is used to covert value to snake_case pattern.
+     * @return {string} string
+     */
+    static snakeCase(value: string): string;
+    /**
+     * The 'camelCase' methid is used to covert value to camelCase pattern.
+     * @return {string} string
+     */
+    camelCase(value: string): string;
+    /**
+     * The 'camelCase' methid is used to covert value to camelCase pattern.
+     * @return {string} string
+     */
+    static camelCase(value: string): string;
+    /**
+    * The 'escape' methid is used to escaping SQL injections.
+    * @return {string} string
+    */
+    escape(value: string): string;
+    /**
+     * The 'escape' methid is used to escaping SQL injections.
+     * @return {string} string
+     */
+    static escape(value: string): string;
+    /**
+     * The 'escapeXSS' methid is used to escaping XSS characters.
+     * @return {string} string
+     */
+    escapeXSS(value: string): string;
+    /**
+     * The 'escapeXSS' methid is used to escaping XSS characters.
+     * @return {string} string
+     */
+    static escapeXSS(value: string): string;
     /**
      * The 'raw' methid is used to allow for raw sql queries to some method in 'DB' or 'Model'.
      * @param {string} sql

package/dist/lib/tspace/DB.js

@@ -24,10 +24,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DB = void 0;
-const AbstractDB_1 = require("./Abstract/AbstractDB");
-const ProxyHandler_1 = require("./ProxyHandler");
+const AbstractDB_1 = require("./Abstracts/AbstractDB");
+const Proxy_1 = require("./Handlers/Proxy");
 const connection_1 = require("../connection");
-const StateHandler_1 = __importDefault(require("./StateHandler"));
+const State_1 = __importDefault(require("./Handlers/State"));
 /**
  * 'DB' class is a component of the database system
  * @param {string?} table table name
@@ -40,7 +40,7 @@ class DB extends AbstractDB_1.AbstractDB {
         this._initialDB();
         if (table)
             this.table(table);
-        return new Proxy(this, ProxyHandler_1.proxyHandler);
+        return new Proxy(this, Proxy_1.proxyHandler);
     }
     /**
      * The 'table' method is used to define the table name.
@@ -178,6 +178,62 @@ class DB extends AbstractDB_1.AbstractDB {
     static generateUUID() {
         return new this().generateUUID();
     }
+    /**
+     * The 'snakeCase' methid is used to covert value to snakeCase pattern.
+     * @return {string} string
+     */
+    snakeCase(value) {
+        return this.$utils.snakeCase(value);
+    }
+    /**
+     * The 'snakeCase' methid is used to covert value to snake_case pattern.
+     * @return {string} string
+     */
+    static snakeCase(value) {
+        return new this().$utils.snakeCase(value);
+    }
+    /**
+     * The 'camelCase' methid is used to covert value to camelCase pattern.
+     * @return {string} string
+     */
+    camelCase(value) {
+        return this.$utils.camelCase(value);
+    }
+    /**
+     * The 'camelCase' methid is used to covert value to camelCase pattern.
+     * @return {string} string
+     */
+    static camelCase(value) {
+        return new this().$utils.camelCase(value);
+    }
+    /**
+    * The 'escape' methid is used to escaping SQL injections.
+    * @return {string} string
+    */
+    escape(value) {
+        return this.$utils.escape(value);
+    }
+    /**
+     * The 'escape' methid is used to escaping SQL injections.
+     * @return {string} string
+     */
+    static escape(value) {
+        return new this().$utils.escape(value);
+    }
+    /**
+     * The 'escapeXSS' methid is used to escaping XSS characters.
+     * @return {string} string
+     */
+    escapeXSS(value) {
+        return this.$utils.escapeXSS(value);
+    }
+    /**
+     * The 'escapeXSS' methid is used to escaping XSS characters.
+     * @return {string} string
+     */
+    static escapeXSS(value) {
+        return new this().$utils.escapeXSS(value);
+    }
     /**
      * The 'raw' methid is used to allow for raw sql queries to some method in 'DB' or 'Model'.
      * @param {string} sql
@@ -276,7 +332,7 @@ class DB extends AbstractDB_1.AbstractDB {
         });
     }
     _initialDB() {
-        this.$state = new StateHandler_1.default(this.$constants('DB'));
+        this.$state = new State_1.default(this.$constants('DB'));
         return this;
     }
 }

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

@@ -0,0 +1,20 @@
+import { RelationQuery, ValidateSchemaDecorator } from "../Interface";
+import { Blueprint } from "./Blueprint";
+export declare const Table: (name: string) => (constructor: Function) => void;
+export declare const TableSingular: () => (constructor: Function) => void;
+export declare const TablePlural: () => (constructor: Function) => void;
+export declare const Column: (blueprint: () => Blueprint) => (target: any, key: string) => void;
+export declare const Validate: (validate: ValidateSchemaDecorator) => (target: any, key: string) => void;
+export declare const UUID: (column?: string) => (constructor: Function) => void;
+export declare const Timestamp: (timestampColumns?: {
+    createdAt: string;
+    updatedAt: string;
+}) => (constructor: Function) => void;
+export declare const SoftDelete: (column?: string) => (constructor: Function) => void;
+export declare const Pattern: (pattern: 'camelCase' | 'snake_case') => (constructor: Function) => void;
+export declare const CamelCase: () => (constructor: Function) => void;
+export declare const SnakeCase: () => (constructor: Function) => void;
+export declare const HasOne: ({ name, as, model, localKey, foreignKey, freezeTable }: RelationQuery) => (target: any, key: string) => void;
+export declare const HasMany: ({ name, as, model, localKey, foreignKey, freezeTable }: RelationQuery) => (target: any, key: string) => void;
+export declare const BelongsTo: ({ name, as, model, localKey, foreignKey, freezeTable }: RelationQuery) => (target: any, key: string) => void;
+export declare const BelongsToMany: ({ name, as, model, localKey, foreignKey, freezeTable, pivot, oldVersion, modelPivot }: RelationQuery) => (target: any, key: string) => void;

package/dist/lib/tspace/Decorator.js

@@ -0,0 +1,166 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BelongsToMany = exports.BelongsTo = exports.HasMany = exports.HasOne = exports.SnakeCase = exports.CamelCase = exports.Pattern = exports.SoftDelete = exports.Timestamp = exports.UUID = exports.Validate = exports.Column = exports.TablePlural = exports.TableSingular = exports.Table = void 0;
+const pluralize_1 = __importDefault(require("pluralize"));
+const Blueprint_1 = require("./Blueprint");
+const Table = (name) => {
+    return (constructor) => {
+        if (constructor.prototype == null)
+            return;
+        constructor.prototype.$table = name;
+    };
+};
+exports.Table = Table;
+const TableSingular = () => {
+    return (constructor) => {
+        if (constructor.prototype == null)
+            return;
+        const name = constructor.name.replace(/([A-Z])/g, (str) => '_' + str.toLowerCase()).slice(1);
+        constructor.prototype.$table = pluralize_1.default.singular(name);
+    };
+};
+exports.TableSingular = TableSingular;
+const TablePlural = () => {
+    return (constructor) => {
+        if (constructor.prototype == null)
+            return;
+        const name = constructor.name.replace(/([A-Z])/g, (str) => '_' + str.toLowerCase()).slice(1);
+        constructor.prototype.$table = pluralize_1.default.plural(name);
+    };
+};
+exports.TablePlural = TablePlural;
+const Column = (blueprint) => {
+    return (target, key) => {
+        if (!(blueprint() instanceof Blueprint_1.Blueprint))
+            return;
+        if (target.$schema == null)
+            target.$schema = {};
+        target.$schema = Object.assign(Object.assign({}, target.$schema), { [key]: blueprint() });
+    };
+};
+exports.Column = Column;
+const Validate = (validate) => {
+    return (target, key) => {
+        if (target.$validateSchema == null)
+            target.$validateSchema = {};
+        target.$validateSchema = Object.assign(Object.assign({}, target.$validateSchema), { [key]: validate });
+    };
+};
+exports.Validate = Validate;
+const UUID = (column) => {
+    return (constructor) => {
+        if (constructor.prototype == null)
+            return;
+        constructor.prototype.$uuid = true;
+        constructor.prototype.$uuidColumn = column;
+    };
+};
+exports.UUID = UUID;
+const Timestamp = (timestampColumns) => {
+    return (constructor) => {
+        if (constructor.prototype == null)
+            return;
+        constructor.prototype.$timestamp = true;
+        constructor.prototype.$timestampColumns = timestampColumns;
+    };
+};
+exports.Timestamp = Timestamp;
+const SoftDelete = (column) => {
+    return (constructor) => {
+        if (constructor.prototype == null)
+            return;
+        constructor.prototype.$softDelete = true;
+        constructor.prototype.$softDeleteColumn = column;
+    };
+};
+exports.SoftDelete = SoftDelete;
+const Pattern = (pattern) => {
+    return (constructor) => {
+        if (constructor.prototype == null)
+            return;
+        constructor.prototype.$pattern = pattern;
+    };
+};
+exports.Pattern = Pattern;
+const CamelCase = () => {
+    return (constructor) => {
+        if (constructor.prototype == null)
+            return;
+        constructor.prototype.$pattern = 'camelCase';
+    };
+};
+exports.CamelCase = CamelCase;
+const SnakeCase = () => {
+    return (constructor) => {
+        if (constructor.prototype == null)
+            return;
+        constructor.prototype.$pattern = 'snake_case';
+    };
+};
+exports.SnakeCase = SnakeCase;
+const HasOne = ({ name, as, model, localKey, foreignKey, freezeTable }) => {
+    return (target, key) => {
+        if (target.$hasOne == null)
+            target.$hasOne = [];
+        target.$hasOne.push({
+            name: name == null ? key : name,
+            as,
+            model,
+            localKey,
+            foreignKey,
+            freezeTable
+        });
+    };
+};
+exports.HasOne = HasOne;
+const HasMany = ({ name, as, model, localKey, foreignKey, freezeTable }) => {
+    return (target, key) => {
+        if (target.$hasMany == null)
+            target.$hasMany = [];
+        target.$hasMany.push({
+            name: name == null ? key : name,
+            as,
+            model,
+            localKey,
+            foreignKey,
+            freezeTable
+        });
+    };
+};
+exports.HasMany = HasMany;
+const BelongsTo = ({ name, as, model, localKey, foreignKey, freezeTable }) => {
+    return (target, key) => {
+        if (target.$belongsTo == null)
+            target.$belongsTo = [];
+        target.$belongsTo.push({
+            name: name == null ? key : name,
+            as,
+            model,
+            localKey,
+            foreignKey,
+            freezeTable
+        });
+    };
+};
+exports.BelongsTo = BelongsTo;
+const BelongsToMany = ({ name, as, model, localKey, foreignKey, freezeTable, pivot, oldVersion, modelPivot }) => {
+    return (target, key) => {
+        if (target.$belongsToMany == null)
+            target.$belongsToMany = [];
+        target.$belongsToMany.push({
+            name: name == null ? key : name,
+            as,
+            model,
+            localKey,
+            foreignKey,
+            freezeTable,
+            pivot,
+            oldVersion,
+            modelPivot
+        });
+    };
+};
+exports.BelongsToMany = BelongsToMany;

package/dist/lib/tspace/{ProxyHandler.js → Handlers/Proxy.js}

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.proxyHandler = void 0;
-const Logger_1 = require("./Logger");
+const Logger_1 = require("../Logger");
 const proxyHandler = {
     set: (self, name, value) => {
         var _a;

package/dist/lib/tspace/{RelationHandler.d.ts → Handlers/Relation.d.ts}

@@ -1,5 +1,5 @@
-import { Relation, RelationQuery } from "./Interface";
-import { Model } from "./Model";
+import { Relation, RelationQuery } from "../../Interface";
+import { Model } from "../Model";
 declare class RelationHandler {
     private MODEL;
     private $constants;
@@ -7,7 +7,7 @@ declare class RelationHandler {
     constructor(model: Model);
     load(parents: Record<string, any>[], relation: Relation): Promise<any[]>;
     loadExists(): string;
-    apply(nameRelations: string[], type: 'all' | 'exists' | 'trashed' | 'default'): Relation[];
+    apply(nameRelations: string[], type: 'all' | 'exists' | 'trashed' | 'count' | 'default'): Relation[];
     callback(nameRelation: string, cb: Function): void;
     hasOne({ name, as, model, localKey, foreignKey, freezeTable }: Relation): void;
     hasMany({ name, as, model, localKey, foreignKey, freezeTable }: Relation): void;
@@ -23,7 +23,7 @@ declare class RelationHandler {
     private _relationMapData;
     private _belongsToMany;
     private _valueInRelation;
-    private _valuePattern;
+    protected _valuePattern(value: string): string;
     private _assertError;
     protected _getState(key: string): any;
     protected _setState(key: string, value: any): void;

package/dist/lib/tspace/{RelationHandler.js → Handlers/Relation.js}

@@ -14,7 +14,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RelationHandler = void 0;
 const pluralize_1 = __importDefault(require("pluralize"));
-const Model_1 = require("./Model");
+const Model_1 = require("../Model");
 class RelationHandler {
     constructor(model) {
         this.MODEL = model;
@@ -36,7 +36,7 @@ class RelationHandler {
                 const data = parent[localKey];
                 if (parent.hasOwnProperty(localKey))
                     return data;
-                this.MODEL['_assertError'](data == null, `Unknown relationship without primary or foreign key in Relation : [${relation === null || relation === void 0 ? void 0 : relation.name}]`);
+                this.MODEL['_assertError'](data == null, `This relationship lacks a primary or foreign key in the '${relation === null || relation === void 0 ? void 0 : relation.name}' relation. Please review the query to identify whether the key '${localKey}' or '${foreignKey}' is missing.`);
             })
                 .filter(d => d != null);
             const parentIds = Array.from(new Set(localKeyId)) || [];
@@ -44,6 +44,19 @@ class RelationHandler {
                 return [];
             const query = relation.query;
             this._assertError(query == null, `Unknown callback query in [Relation : ${relation.name}]`);
+            if (relation.count) {
+                const results = yield query
+                    .whereIn(foreignKey, parentIds)
+                    .select(foreignKey)
+                    .selectRaw(`${this.$constants('COUNT')}(${foreignKey}) ${this.$constants('AS')} \`aggregate\``)
+                    .debug(this._getState('DEBUG'))
+                    .when(relation.trashed, (query) => query.onlyTrashed())
+                    .when(relation.all, (query) => query.disableSoftDelete())
+                    .bind(this.MODEL['$pool'].get())
+                    .groupBy(foreignKey)
+                    .get();
+                return this._relationMapData(parents, results, relation);
+            }
             const results = yield query
                 .whereIn(foreignKey, parentIds)
                 .debug(this._getState('DEBUG'))
@@ -70,6 +83,8 @@ class RelationHandler {
             const cloneRelations = clone['_getState']('RELATIONS');
             if (cloneRelations.length) {
                 for (const r of cloneRelations) {
+                    if (!r.exists)
+                        continue;
                     if (r.query == null)
                         continue;
                     const sql = (_c = (_b = clone['$relation']) === null || _b === void 0 ? void 0 : _b._handleRelationsExists(r)) !== null && _c !== void 0 ? _c : '';
@@ -82,21 +97,21 @@ class RelationHandler {
                     : new Model_1.Model().table(String(pivot));
                 const sql = clone
                     .bind(this.MODEL['$pool'].get())
-                    .select(this._getState('PRIMARY_KEY'))
-                    .whereReference(`\`${query.getTableName()}\`.\`${foreignKey}\``, `\`${pivot}\`.\`${localKey}\``)
+                    .selectRaw("1")
+                    .whereReference(`\`${query.getTableName()}\`.\`${foreignKey}\``, `\`${thisPivot.getTableName()}\`.\`${localKey}\``)
                     .toString();
                 thisPivot.whereExists(sql);
                 const sqlPivot = thisPivot
                     .bind(this.MODEL['$pool'].get())
-                    .select(thisPivot['$state'].get('PRIMARY_KEY'))
-                    .whereReference(`\`${this.MODEL['getTableName']()}\`.\`${foreignKey}\``, `\`${pivot}\`.\`${this._valuePattern([pluralize_1.default.singular(this.MODEL['getTableName']()), foreignKey].join("_"))}\``)
+                    .selectRaw("1")
+                    .whereReference(`\`${this.MODEL['getTableName']()}\`.\`${foreignKey}\``, `\`${thisPivot.getTableName()}\`.\`${this._valuePattern([pluralize_1.default.singular(this.MODEL['getTableName']()), foreignKey].join("_"))}\``)
                     .toString();
                 this.MODEL['whereExists'](sqlPivot);
                 continue;
             }
             const sql = clone
                 .bind(this.MODEL['$pool'].get())
-                .select(this._getState('PRIMARY_KEY'))
+                .selectRaw("1")
                 .whereReference(`\`${this.MODEL['getTableName']()}\`.\`${localKey}\``, `\`${query.getTableName()}\`.\`${foreignKey}\``)
                 .toString();
             this.MODEL['whereExists'](sql);
@@ -108,7 +123,7 @@ class RelationHandler {
         const relations = nameRelations.map((name) => {
             var _a, _b, _c;
             const relation = (_a = this._getState('RELATION')) === null || _a === void 0 ? void 0 : _a.find((data) => data.name === name);
-            this._assertError(relation == null, `This Relation "${name}" not be register in Model "${(_b = this.constructor) === null || _b === void 0 ? void 0 : _b.name}"`);
+            this._assertError(relation == null, `The relation '${name}' is not registered in the model '${(_b = this.MODEL.constructor) === null || _b === void 0 ? void 0 : _b.name}'.`);
             const relationHasExists = (_c = Object.values(this.$constants('RELATIONSHIP'))) === null || _c === void 0 ? void 0 : _c.includes(relation.relation);
             this._assertError(!relationHasExists, `Unknown relationship in [${this.$constants('RELATIONSHIP')}] !`);
             if (relation.query == null)
@@ -133,7 +148,7 @@ class RelationHandler {
     callback(nameRelation, cb) {
         var _a, _b;
         const relation = this._getState('RELATIONS').find((data) => data.name === nameRelation);
-        this._assertError(relation == null, `This Relation "${nameRelation}" not be register in Model "${(_a = this.constructor) === null || _a === void 0 ? void 0 : _a.name}"`);
+        this._assertError(relation == null, `This Relation "${nameRelation}" not be register in Model "${(_a = this.MODEL.constructor) === null || _a === void 0 ? void 0 : _a.name}"`);
         const relationHasExists = (_b = Object.values(this.$constants('RELATIONSHIP'))) === null || _b === void 0 ? void 0 : _b.includes(relation.relation);
         this._assertError(!relationHasExists, `unknown relationship in [${this.$constants('RELATIONSHIP')}] !`);
         relation.query = cb(new relation.model());
@@ -284,7 +299,7 @@ class RelationHandler {
         return;
     }
     _handleRelationsExists(relation) {
-        var _a, _b, _c;
+        var _a, _b, _c, _d;
         this._assertError(!((_a = Object.keys(relation)) === null || _a === void 0 ? void 0 : _a.length), `unknown [relation]`);
         const { localKey, foreignKey } = this._valueInRelation(relation);
         const query = relation.query;
@@ -293,16 +308,46 @@ class RelationHandler {
         const cloneRelations = clone['_getState']('RELATIONS');
         if (cloneRelations.length) {
             for (const r of cloneRelations) {
+                if (!r.exists)
+                    continue;
                 if (r.query == null)
                     continue;
-                const sql = (_c = (_b = clone['$relation']) === null || _b === void 0 ? void 0 : _b._handleRelationsExists(r)) !== null && _c !== void 0 ? _c : '';
+                if (r.relation === this.$constants('RELATIONSHIP').belongsToMany) {
+                    const data = (_b = clone['$relation']) === null || _b === void 0 ? void 0 : _b._valueInRelation(r);
+                    if (data == null)
+                        continue;
+                    const { modelPivot, pivot, foreignKey } = data;
+                    const thisPivot = modelPivot == null && pivot == null
+                        ? new Model_1.Model().table(`${this._valuePattern([
+                            pluralize_1.default.singular(clone.getTableName()),
+                            pluralize_1.default.singular(this.MODEL['getTableName']())
+                        ].join("_"))}`)
+                        : modelPivot ? new modelPivot : new Model_1.Model().table(`${pivot}`);
+                    const sql = clone
+                        .bind(this.MODEL['$pool'].get())
+                        .selectRaw("1")
+                        .whereReference(`\`${clone.getTableName()}\`.\`${foreignKey}\``, `\`${thisPivot.getTableName()}\`.\`${this._valuePattern([
+                        pluralize_1.default.singular(clone.getTableName()),
+                        localKey
+                    ].join('_'))}\``)
+                        .toString();
+                    thisPivot.whereExists(sql);
+                    const sqlPivot = thisPivot
+                        .bind(this.MODEL['$pool'].get())
+                        .selectRaw("1")
+                        .whereReference(`\`${this.MODEL['getTableName']()}\`.\`${foreignKey}\``, `\`${thisPivot.getTableName()}\`.\`${this._valuePattern([pluralize_1.default.singular(this.MODEL['getTableName']()), foreignKey].join("_"))}\``)
+                        .toString();
+                    clone.whereExists(sqlPivot);
+                    continue;
+                }
+                const sql = (_d = (_c = clone['$relation']) === null || _c === void 0 ? void 0 : _c._handleRelationsExists(r)) !== null && _d !== void 0 ? _d : '';
                 clone.whereExists(sql);
             }
         }
         const sql = clone
             .bind(this.MODEL['$pool'].get())
-            .select(this._getState('PRIMARY_KEY'))
-            .whereReference(`\`${this.MODEL['getTableName']()}\`.\`${localKey}\``, `\`${query.getTableName()}\`.\`${foreignKey}\``)
+            .selectRaw("1")
+            .whereReference(`\`${this.MODEL['getTableName']()}\`.\`${localKey}\``, `\`${clone.getTableName()}\`.\`${foreignKey}\``)
             .toString();
         return sql;
     }
@@ -311,16 +356,16 @@ class RelationHandler {
         this._setState('RELATION', [...this._getState('RELATION'), relation]);
         this.MODEL['with'](nameRelation);
         const r = this._getState('RELATIONS').find((data) => data.name === nameRelation);
-        this._assertError(relation == null, `This Relation "${nameRelation}" not be register in Model "${(_a = this.constructor) === null || _a === void 0 ? void 0 : _a.name}"`);
-        this._assertError(!Object.values(this.$constants('RELATIONSHIP')).includes(r.relation), `unknown relationship in [${this.$constants('RELATIONSHIP')}] !`);
+        this._assertError(relation == null, `The relation '${nameRelation}' is not registered in the model '${(_a = this.MODEL.constructor) === null || _a === void 0 ? void 0 : _a.name}'.`);
         return r;
     }
     _functionRelationName() {
         const functionName = [...this.$logger.get()][this.$logger.get().length - 2];
         return functionName.replace(/([A-Z])/g, (str) => `_${str.toLowerCase()}`);
     }
-    _relationMapData(dataParents, dataChilds, relations) {
-        const { name, as, relation, localKey, foreignKey } = this._valueInRelation(relations);
+    _relationMapData(dataParents, dataChilds, r) {
+        var _a;
+        const { name, as, relation, localKey, foreignKey } = this._valueInRelation(r);
         const keyRelation = as !== null && as !== void 0 ? as : name;
         for (const dataParent of dataParents) {
             const relationIsHasOneOrBelongsTo = [
@@ -329,11 +374,15 @@ class RelationHandler {
             ].some(r => r === relation);
             dataParent[keyRelation] = [];
             if (relationIsHasOneOrBelongsTo)
-                dataParent[keyRelation] = null;
+                dataParent[keyRelation] = r.count ? 0 : null;
             if (!dataChilds.length)
                 continue;
             for (const dataChild of dataChilds) {
                 if (dataChild[foreignKey] === dataParent[localKey]) {
+                    if (r.count) {
+                        dataParent[keyRelation] = (_a = dataChild === null || dataChild === void 0 ? void 0 : dataChild.aggregate) !== null && _a !== void 0 ? _a : 0;
+                        continue;
+                    }
                     const relationIsHasOneOrBelongsTo = [
                         this.$constants('RELATIONSHIP').hasOne,
                         this.$constants('RELATIONSHIP').belongsTo
@@ -351,14 +400,14 @@ class RelationHandler {
         return dataParents;
     }
     _belongsToMany(parents, relation) {
-        var _a;
+        var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
             const { name, foreignKey, localKey, pivot, oldVersion, modelPivot } = this._valueInRelation(relation);
             const localKeyId = parents.map((parent) => {
                 const data = parent[foreignKey];
                 if (parent.hasOwnProperty(foreignKey))
                     return data;
-                this._assertError(data == null, `Unknown relationship without primary or foreign key in Relation : [${relation === null || relation === void 0 ? void 0 : relation.name}]`);
+                this._assertError(data == null, `This relationship lacks a primary or foreign key in the '${relation === null || relation === void 0 ? void 0 : relation.name}' relation. Please review the query to identify whether the key '${localKey}' or '${foreignKey}' is missing.`);
             }).filter((d) => d != null);
             const mainResultIds = Array.from(new Set(localKeyId));
             if (!mainResultIds.length && this._getState('RELATIONS_EXISTS'))
@@ -371,23 +420,49 @@ class RelationHandler {
             const pivotTable = String(((_a = relation.pivot) !== null && _a !== void 0 ? _a : pivot));
             const sqlPivotExists = new Model_1.Model()
                 .copyModel(modelRelation)
-                .select(this._getState('PRIMARY_KEY'))
+                .selectRaw("1")
                 .whereReference(`\`${modelRelation.getTableName()}\`.\`${foreignKey}\``, `\`${pivotTable}\`.\`${localKey}\``)
                 .toString();
             const queryPivot = modelPivot
                 ? new modelPivot()
                 : new Model_1.Model().table(pivotTable);
-            const sqlPivot = queryPivot
+            if (relation.count) {
+                const pivotResults = yield queryPivot
+                    .whereIn(localKeyPivotTable, mainResultIds)
+                    .select(localKeyPivotTable)
+                    .selectRaw(`${this.$constants('COUNT')}(${localKeyPivotTable}) ${this.$constants('AS')} \`aggregate\``)
+                    .when(relation.exists, (query) => query.whereExists(sqlPivotExists))
+                    .when(relation.trashed, (query) => query.onlyTrashed())
+                    .when(relation.all, (query) => query.disableSoftDelete())
+                    .groupBy(localKeyPivotTable)
+                    .bind(this.MODEL['$pool'].get())
+                    .debug(this._getState('DEBUG'))
+                    .get();
+                for (const parent of parents) {
+                    if (parent[name] == null)
+                        parent[name] = 0;
+                    for (const pivotResult of pivotResults) {
+                        if (pivotResult[localKeyPivotTable] !== parent[foreignKey])
+                            continue;
+                        parent[name] = (_b = pivotResult.aggregate) !== null && _b !== void 0 ? _b : 0;
+                    }
+                }
+                if (this._getState('HIDDEN').length)
+                    this.MODEL['_hiddenColumnModel'](parents);
+                return parents;
+            }
+            const pivotResults = yield queryPivot
                 .whereIn(localKeyPivotTable, mainResultIds)
                 .when(relation.exists, (query) => query.whereExists(sqlPivotExists))
                 .when(relation.trashed, (query) => query.onlyTrashed())
                 .when(relation.all, (query) => query.disableSoftDelete())
-                .toString();
-            const pivotResults = yield this.MODEL['_queryStatement'](sqlPivot);
+                .bind(this.MODEL['$pool'].get())
+                .debug(this._getState('DEBUG'))
+                .get();
             const relationIds = Array.from(new Set(pivotResults
                 .map((pivotResult) => pivotResult[relationForeignKey])
                 .filter((d) => d != null)));
-            const relationResults = yield this.MODEL['_queryStatement'](modelRelation
+            const relationResults = yield this.MODEL.rawQuery(modelRelation
                 .whereIn(mainlocalKey, relationIds)
                 .when(relation.trashed, (query) => query.disableSoftDelete())
                 .toString());
@@ -435,8 +510,8 @@ class RelationHandler {
     }
     _valueInRelation(relationModel) {
         var _a, _b, _c;
-        this._assertError((relationModel === null || relationModel === void 0 ? void 0 : relationModel.query) instanceof Promise, 'Nested Relation isn\'t supported Promise method');
-        this._assertError(!((relationModel === null || relationModel === void 0 ? void 0 : relationModel.query) instanceof Model_1.Model), 'Callback function supported instance of Model only');
+        this._assertError((relationModel === null || relationModel === void 0 ? void 0 : relationModel.query) instanceof Promise, 'The Promise method does not support nested relations.');
+        this._assertError(!((relationModel === null || relationModel === void 0 ? void 0 : relationModel.query) instanceof Model_1.Model), 'The callback function only supports instances of the Model class.');
         const relation = relationModel.relation;
         const model = (_a = relationModel.model) === null || _a === void 0 ? void 0 : _a.name;
         const modelPivot = relationModel.modelPivot;
@@ -447,7 +522,7 @@ class RelationHandler {
         let pivot = null;
         const name = relationModel.name;
         const as = relationModel.as;
-        this._assertError(!model || model == null, 'Not found model');
+        this._assertError(!model || model == null, 'Model not found.');
         let localKey = this._valuePattern(relationModel.localKey
             ? relationModel.localKey
             : this._getState('PRIMARY_KEY'));