tspace-mysql 1.4.7 → 1.4.8

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/{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;
@@ -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);
@@ -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;
     }
@@ -319,8 +364,9 @@ class RelationHandler {
         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 +375,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,7 +401,7 @@ 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) => {
@@ -371,23 +421,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());

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

@@ -1,5 +1,6 @@
-import { AbstractModel } from './Abstract/AbstractModel';
-import { Relation, Pagination, RelationQuery, ValidateSchema } from './Interface';
+import { AbstractModel } from './Abstracts/AbstractModel';
+import { Blueprint } from './Blueprint';
+import { Relation, Pagination, RelationQuery, ValidateSchema } from '../Interface';
 /**
  *
  * 'Model' class is a representation of a database table
@@ -92,7 +93,7 @@ declare class Model extends AbstractModel {
      * }
      * @return {this} this
      */
-    protected useSchema(schema: Record<string, any>): this;
+    protected useSchema(schema: Record<string, Blueprint>): this;
     /**
      *
      * The "useRegistry" method is used to define Function to results.
@@ -105,7 +106,6 @@ declare class Model extends AbstractModel {
      *        this.useRegistry()
      *     }
      * }
-     
      */
     protected useRegistry(): this;
     /**
@@ -176,7 +176,27 @@ declare class Model extends AbstractModel {
      * }
      */
     protected usePattern(pattern: "snake_case" | "camelCase"): this;
+    /**
+     * The "useCamelCase" method is used to assign pattern camelCase.
+     * @return {this} this
+     * @example
+     * class User extends Model {
+     *     constructor() {
+     *        this.useCamelCase()
+     *     }
+     * }
+     */
     protected useCamelCase(): this;
+    /**
+     * The "SnakeCase" method is used to assign pattern snake_case.
+     * @return {this} this
+     * @example
+     * class User extends Model {
+     *     constructor() {
+     *        this.SnakeCase()
+     *     }
+     * }
+     */
     protected useSnakeCase(): this;
     /**
      * The "useSoftDelete" refer to a feature that allows you to "soft delete" records from a database table instead of permanently deleting them.
@@ -331,7 +351,7 @@ declare class Model extends AbstractModel {
      * @override
      * @return {promise<string>} string
      */
-    protected _exceptColumns(): Promise<string[]>;
+    protected exceptColumns(): Promise<string[]>;
     /**
      * Build  method for relation in model
      * @param    {string} name name relation registry in your model
@@ -339,6 +359,36 @@ declare class Model extends AbstractModel {
      * @return   {this}   this
      */
     protected buildMethodRelation(name: string, callback?: Function): this;
+    /**
+     *
+     * The 'makeSelectStatement' method is used to make select statement.
+     * @return {Promise<string>} string
+     */
+    makeSelectStatement(): Promise<string>;
+    /**
+     *
+     * The 'makeInsertStatement' method is used to make insert table statement.
+     * @return {Promise<string>} string
+     */
+    makeInsertStatement(): Promise<string>;
+    /**
+     *
+     * The 'makeUpdateStatement' method is used to make update table statement.
+     * @return {Promise<string>} string
+     */
+    makeUpdateStatement(): Promise<string>;
+    /**
+     *
+     * The 'makeDeleteStatement' method is used to make delete statement.
+     * @return {Promise<string>} string
+     */
+    makeDeleteStatement(): Promise<string>;
+    /**
+     *
+     * The 'makeCreateStatement' method is used to make create table statement.
+     * @return {Promise<string>} string
+     */
+    makeCreateStatement(): Promise<string>;
     /**
      *
      * Clone instance of model
@@ -446,6 +496,15 @@ declare class Model extends AbstractModel {
      * @return {this} this
      */
     withAll(...nameRelations: string[]): this;
+    /**
+    * The 'withAll' method is used to eager load related (relations) data when retrieving records from a database.
+    *
+    * Eager loading allows you to retrieve a primary model and its related models in a more efficient
+    * It's method ignore soft delete
+    * @param {...string} nameRelations if data exists return blank
+    * @return {this} this
+    */
+    withCount(...nameRelations: string[]): this;
     /**
      * The 'withTrashed' method is used to eager load related (relations) data when retrieving records from a database.
      *
@@ -986,13 +1045,14 @@ declare class Model extends AbstractModel {
      * @return {this} this this
      */
     insertNotExists(data: Record<string, string | number | boolean | null | undefined>): this;
+    getSchemaModel(): Record<string, any> | null;
+    validation(schema?: ValidateSchema): this;
     /**
-     *
-     * get schema from table
-     * @return {this} this this
+     * The 'bindPattern' method is used to covert column relate with pattern
+     * @param {string} column
+     * @return {string} return table.column
      */
-    getSchema(): Promise<any>;
-    getSchemaModel(): Record<string, any> | null;
+    bindPattern(column: string): string;
     /**
      * @override Method
      * @return {Promise<Record<string,any> | any[] | null | undefined>}
@@ -1020,6 +1080,7 @@ declare class Model extends AbstractModel {
         insert: () => string;
         update: () => string;
         delete: () => string;
+        where: () => string | null;
         any: () => string;
     };
     private _showOnly;