tspace-mysql 1.2.3 → 1.2.5

package/README.md

@@ -374,7 +374,7 @@ class User extends Model {
      * this.useTable('users')
      * this.useTableSingular() // 'user'
      * this.useTablePlural() // 'users'
-     * this.usePattern('snake_case')   
+     * this.usePattern('snake_case') // by defalut snake_case
      * this.useUUID('uuid') // => runing a uuid (universally unique identifier) when insert new data
      * this.useRegistry()
      * this.useSchema({

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

@@ -65,6 +65,14 @@ declare class Database extends AbstractDatabase {
      * @return {this}
      */
     where(column: string, operator?: any, value?: any): this;
+    /**
+     * where using object operator only '='
+     * @param {Object} columns
+     * @return {this}
+     */
+    whereObject(columns: {
+        [key: string]: any;
+    }): this;
     /**
      * if has 2 arguments  default operator '='
      * @param {string} column

package/dist/lib/tspace/Database.js

@@ -151,6 +151,30 @@ class Database extends AbstractDatabase_1.default {
         ].join(' '));
         return this;
     }
+    /**
+     * where using object operator only '='
+     * @param {Object} columns
+     * @return {this}
+     */
+    whereObject(columns) {
+        for (const column in columns) {
+            const operator = '=';
+            const value = columns[column];
+            if (!this._queryWhereIsExists()) {
+                this.$state.set('WHERE', [
+                    `${this.$constants('WHERE')}`,
+                    `${this._bindTableAndColumnInQueryWhere(column)} ${operator} '${value}'`
+                ].join(' '));
+                continue;
+            }
+            this.$state.set('WHERE', [
+                `${this.$state.get('WHERE')}`,
+                `${this.$constants('AND')}`,
+                `${this._bindTableAndColumnInQueryWhere(column)} ${operator} '${value}'`
+            ].join(' '));
+        }
+        return this;
+    }
     /**
      * if has 2 arguments  default operator '='
      * @param {string} column

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

@@ -8,6 +8,8 @@ export interface Relation {
     pivot?: string | undefined;
     query?: any | undefined;
     relation?: Object | undefined;
+    exists?: boolean | undefined;
+    oldVersion?: boolean | undefined;
 }
 export interface RelationQuery {
     name?: string;

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

@@ -148,11 +148,11 @@ declare class Model extends AbstractModel {
      */
     withExists(...nameRelations: Array<string>): this;
     /**
-    *
-    * Use relations in registry of model return only exists result of relation query
-    * @param {...string} nameRelations if data exists return blank
-    * @return {this} this
-    */
+     *
+     * Use relations in registry of model return only exists result of relation query
+     * @param {...string} nameRelations if data exists return blank
+     * @return {this} this
+     */
     has(...nameRelations: Array<string>): this;
     /**
      *
@@ -231,7 +231,7 @@ declare class Model extends AbstractModel {
      * @property {string} relation.freezeTable
      * @return   {this}   this
      */
-    protected belongsToMany({ name, as, model, localKey, foreignKey, freezeTable, pivot }: Relation): this;
+    protected belongsToMany({ name, as, model, localKey, foreignKey, freezeTable, pivot, oldVersion }: Relation): this;
     /**
      * Assign the relation in model Objects
      * @param    {object}  relation registry relation in your model

package/dist/lib/tspace/Model.js

@@ -170,12 +170,12 @@ class Model extends AbstractModel_1.AbstractModel {
      * @return   {this}   this
      */
     buildMethodRelation(name, callback) {
-        var _a;
+        var _a, _b;
         this.with(name);
         const r = this.$state.get('WITH').find((data) => data.name === name);
-        this._assertError(r == null, `relation ${name} not be register !`);
-        const relationHasExists = (_a = Object.values(this.$constants('RELATIONSHIP'))) === null || _a === void 0 ? void 0 : _a.includes(r.relation);
-        this._assertError(!relationHasExists, `unknown relationship in [${this.$constants('RELATIONSHIP')}] !`);
+        this._assertError(r == null, `This Relation ${name} not be register in Model ${(_a = this.constructor) === null || _a === void 0 ? void 0 : _a.name}`);
+        const relationHasExists = (_b = Object.values(this.$constants('RELATIONSHIP'))) === null || _b === void 0 ? void 0 : _b.includes(r.relation);
+        this._assertError(!relationHasExists, `Unknown Relationship in [${this.$constants('RELATIONSHIP')}] !`);
         if (callback == null) {
             r.query = new r.model();
             return this;
@@ -202,7 +202,7 @@ class Model extends AbstractModel_1.AbstractModel {
      * @return {Model} Model
      */
     copyModel(instance, options) {
-        this._assertError(!(instance instanceof Model), 'value is not a instanceof Model');
+        this._assertError(!(instance instanceof Model), 'Value is not a instanceof Model');
         const copy = Object.fromEntries(instance.$state.get());
         const newInstance = new Model();
         newInstance.$state.clone(copy);
@@ -251,11 +251,11 @@ class Model extends AbstractModel_1.AbstractModel {
      */
     with(...nameRelations) {
         const relations = nameRelations.map((name) => {
-            var _a, _b;
+            var _a, _b, _c;
             const relation = (_a = this.$state.get('RELATION')) === null || _a === void 0 ? void 0 : _a.find((data) => data.name === name);
-            this._assertError(relation == null, `relation ${name} not be register !`);
-            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')}] !`);
+            this._assertError(relation == null, `This Relation ${name} not be register in Model ${(_b = this.constructor) === null || _b === void 0 ? void 0 : _b.name}`);
+            const relationHasExists = (_c = Object.values(this.$constants('RELATIONSHIP'))) === null || _c === void 0 ? void 0 : _c.includes(relation.relation);
+            this._assertError(!relationHasExists, `Unknown relationship in [${this.$constants('RELATIONSHIP')}] !`);
             if (relation.query == null)
                 relation.query = new relation.model();
             return relation;
@@ -280,20 +280,39 @@ class Model extends AbstractModel_1.AbstractModel {
      * @return {this} this
      */
     withExists(...nameRelations) {
-        this.with(...nameRelations);
         this.$state.set('WITH_EXISTS', true);
+        const relations = nameRelations.map((name) => {
+            var _a, _b, _c;
+            const relation = (_a = this.$state.get('RELATION')) === null || _a === void 0 ? void 0 : _a.find((data) => data.name === name);
+            this._assertError(relation == null, `This Relation ${name} not be register in Model ${(_b = this.constructor) === null || _b === void 0 ? void 0 : _b.name}`);
+            const relationHasExists = (_c = Object.values(this.$constants('RELATIONSHIP'))) === null || _c === void 0 ? void 0 : _c.includes(relation.relation);
+            this._assertError(!relationHasExists, `unknown relationship in [${this.$constants('RELATIONSHIP')}] !`);
+            if (relation.query == null)
+                relation.query = new relation.model();
+            relation.exists = true;
+            return relation;
+        });
+        relations.sort((cur, prev) => cur.relation.length - prev.relation.length);
+        const setRelations = this.$state.get('WITH').length
+            ? [...relations.map((w) => {
+                    const exists = this.$state.get('WITH').find((r) => r.name === w.name);
+                    if (exists)
+                        return null;
+                    return w;
+                }).filter((d) => d != null),
+                ...this.$state.get('WITH')]
+            : relations;
+        this.$state.set('WITH', setRelations);
         return this;
     }
     /**
-    *
-    * Use relations in registry of model return only exists result of relation query
-    * @param {...string} nameRelations if data exists return blank
-    * @return {this} this
-    */
+     *
+     * Use relations in registry of model return only exists result of relation query
+     * @param {...string} nameRelations if data exists return blank
+     * @return {this} this
+     */
     has(...nameRelations) {
-        this.with(...nameRelations);
-        this.$state.set('WITH_EXISTS', true);
-        return this;
+        return this.withExists(...nameRelations);
     }
     /**
      *
@@ -303,10 +322,10 @@ class Model extends AbstractModel_1.AbstractModel {
      * @return {this} this
      */
     withQuery(nameRelation, callback) {
-        var _a;
+        var _a, _b;
         const relation = this.$state.get('WITH').find((data) => data.name === nameRelation);
-        this._assertError(relation == null, `relation ${nameRelation} not be register !`);
-        const relationHasExists = (_a = Object.values(this.$constants('RELATIONSHIP'))) === null || _a === void 0 ? void 0 : _a.includes(relation.relation);
+        this._assertError(relation == null, `This Relation ${nameRelation} not be register in Model ${(_a = this.constructor) === null || _a === void 0 ? void 0 : _a.name}`);
+        const relationHasExists = (_b = Object.values(this.$constants('RELATIONSHIP'))) === null || _b === void 0 ? void 0 : _b.includes(relation.relation);
         this._assertError(!relationHasExists, `unknown relationship in [${this.$constants('RELATIONSHIP')}] !`);
         relation.query = callback(new relation.model());
         return this;
@@ -318,27 +337,7 @@ class Model extends AbstractModel_1.AbstractModel {
      * @return {this} this
      */
     relations(...nameRelations) {
-        const relations = nameRelations.map((name) => {
-            var _a, _b;
-            const relation = (_a = this.$state.get('RELATION')) === null || _a === void 0 ? void 0 : _a.find((data) => data.name === name);
-            this._assertError(relation == null, `relation ${name} not be register !`);
-            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')}] !`);
-            if (relation.query == null)
-                relation.query = new relation.model();
-            return relation;
-        });
-        relations.sort((cur, prev) => cur.relation.length - prev.relation.length);
-        const setRelations = this.$state.get('WITH').length
-            ? [...relations.map((w) => {
-                    const exists = this.$state.get('WITH').find((r) => r.name === w.name);
-                    if (exists)
-                        return null;
-                    return w;
-                }).filter((d) => d != null), ...this.$state.get('WITH')]
-            : relations;
-        this.$state.set('WITH', setRelations);
-        return this;
+        return this.with(...nameRelations);
     }
     /**
      *
@@ -347,9 +346,7 @@ class Model extends AbstractModel_1.AbstractModel {
      * @return {this}
      */
     relationsExists(...nameRelations) {
-        this.with(...nameRelations);
-        this.$state.set('WITH_EXISTS', true);
-        return this;
+        return this.withExists(...nameRelations);
     }
     /**
      *
@@ -359,13 +356,7 @@ class Model extends AbstractModel_1.AbstractModel {
      * @return {this} this
      */
     relationQuery(nameRelation, callback) {
-        var _a;
-        const relation = this.$state.get('WITH').find((data) => data.name === nameRelation);
-        this._assertError(relation == null, `relation ${nameRelation} not be register !`);
-        const relationHasExists = (_a = Object.values(this.$constants('RELATIONSHIP'))) === null || _a === void 0 ? void 0 : _a.includes(relation.relation);
-        this._assertError(!relationHasExists, `unknown relationship in [${this.$constants('RELATIONSHIP')}] !`);
-        relation.query = callback(new relation.model());
-        return this;
+        return this.withQuery(nameRelation, callback);
     }
     /**
      * Assign the relation in model Objects
@@ -453,7 +444,7 @@ class Model extends AbstractModel_1.AbstractModel {
      * @property {string} relation.freezeTable
      * @return   {this}   this
      */
-    belongsToMany({ name, as, model, localKey, foreignKey, freezeTable, pivot }) {
+    belongsToMany({ name, as, model, localKey, foreignKey, freezeTable, pivot, oldVersion }) {
         const relation = {
             name,
             model,
@@ -463,6 +454,7 @@ class Model extends AbstractModel_1.AbstractModel {
             foreignKey,
             freezeTable,
             pivot,
+            oldVersion,
             query: null
         };
         this.$state.set('RELATION', [...this.$state.get('RELATION'), relation]);
@@ -1481,6 +1473,7 @@ class Model extends AbstractModel_1.AbstractModel {
         var _a, _b, _c, _d;
         const relation = relationModel.relation;
         const model = (_a = relationModel.model) === null || _a === void 0 ? void 0 : _a.name;
+        const oldVersion = relationModel.oldVersion;
         const table = relationModel.freezeTable
             ? relationModel.freezeTable
             : (_b = relationModel.query) === null || _b === void 0 ? void 0 : _b._tableName();
@@ -1525,7 +1518,7 @@ class Model extends AbstractModel_1.AbstractModel {
                 pluralize_1.default.singular((_d = relationModel.query) === null || _d === void 0 ? void 0 : _d._tableName())
             ].sort().join('_'));
         }
-        return { name, as, relation, table, localKey, foreignKey, model, pivot };
+        return { name, as, relation, table, localKey, foreignKey, model, pivot, oldVersion };
     }
     _handleSoftDelete() {
         if (this.$state.get('SOFT_DELETE')) {
@@ -1600,23 +1593,27 @@ class Model extends AbstractModel_1.AbstractModel {
             return;
         const typeOf = (data) => Object.prototype.toString.apply(data).slice(8, -1).toLocaleLowerCase();
         for (const result of results) {
-            for (const key in result) {
-                const s = schema[key];
+            for (const column in result) {
+                const s = schema[column];
+                if (s == null && this.$state.get('SELECT').includes('*'))
+                    this._assertError(`Not found this column [${column}] in schema`);
                 if (s == null)
-                    this._assertError(`not found this column [${key}] in schema`);
+                    continue;
                 const regexDate = /[0-9]{4}-(0[1-9]|1[0-2])-(0[1-9]|[1-2][0-9]|3[0-1])/;
                 const regexDateTime = /[0-9]{4}-(0[1-9]|1[0-2])-(0[1-9]|[1-2][0-9]|3[0-1]) (2[0-3]|[01][0-9]):[0-5][0-9]/;
-                if (regexDate.test(result[key]) || regexDateTime.test(result[key])) {
-                    if (typeOf(new Date(result[key])) === typeOf(new s()))
+                if (regexDate.test(result[column]) || regexDateTime.test(result[column])) {
+                    if (typeOf(new Date(result[column])) === typeOf(new s()))
                         continue;
-                    this._assertError(`this column [${key}] is invalid schema field type`);
+                    this._assertError(`This column [${column}] is invalid schema field type`);
                 }
-                if (typeOf(result[key]) === typeOf(new s()))
+                if (result[column] === null)
+                    continue;
+                if (typeOf(result[column]) === typeOf(new s()))
                     continue;
-                this._assertError(`this column [${key}] is invalid schema field type`);
+                this._assertError(`This column [${column}] is invalid schema field type`);
             }
         }
-        return this;
+        return;
     }
     _execute({ sql, type, message, options }) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -1721,6 +1718,8 @@ class Model extends AbstractModel_1.AbstractModel {
             const relation = relations[index];
             if (!((_a = Object.keys(relation)) === null || _a === void 0 ? void 0 : _a.length))
                 continue;
+            if (relation.exists == null)
+                continue;
             const { localKey, foreignKey, pivot } = this._valueInRelation(relation);
             const query = relation.query;
             this._assertError(query == null, `unknown callback query in [relation : '${relation.name}']`);
@@ -1734,13 +1733,13 @@ class Model extends AbstractModel_1.AbstractModel {
                 }
             }
             if (relation.relation === this.$constants('RELATIONSHIP').belongsToMany) {
+                const thisPivot = new Model();
+                thisPivot.$state.set('TABLE_NAME', `\`${pivot}\``);
                 const sql = clone
                     .bind(this.$pool.get())
-                    .whereReference(`\`${this._tableName()}\`.\`${localKey}\``, `\`${query._tableName()}\`.\`${foreignKey}\``)
+                    .whereReference(`\`${query._tableName()}\`.\`${foreignKey}\``, `\`${pivot}\`.\`${localKey}\``)
                     .toString();
-                this.whereExists(sql);
-                const thisPivot = new Model();
-                thisPivot.$state.set('TABLE_NAME', `\`${pivot}\``);
+                thisPivot.whereExists(sql);
                 const sqlPivot = thisPivot
                     .bind(this.$pool.get())
                     .whereReference(`\`${this._tableName()}\`.\`${foreignKey}\``, `\`${pivot}\`.\`${this._valuePattern([pluralize_1.default.singular(this._tableName()), foreignKey].join("_"))}\``)
@@ -1786,7 +1785,7 @@ class Model extends AbstractModel_1.AbstractModel {
     _belongsToMany(dataFromParent, relation) {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
-            const { name, foreignKey, pivot } = this._valueInRelation(relation);
+            const { name, foreignKey, localKey, pivot, oldVersion } = this._valueInRelation(relation);
             const pivotTable = String(((_a = relation.pivot) !== null && _a !== void 0 ? _a : pivot));
             const localKeyId = dataFromParent.map((parent) => {
                 const data = parent[foreignKey];
@@ -1795,7 +1794,7 @@ class Model extends AbstractModel_1.AbstractModel {
                 }
                 return data;
             }).filter((data) => data != null);
-            const dataPerentId = Array.from(new Set(localKeyId)).join(',') || [];
+            const dataPerentId = Array.from(new Set(localKeyId));
             if (!dataPerentId.length && this.$state.get('WITH_EXISTS'))
                 return [];
             const modelOther = new relation.model();
@@ -1803,35 +1802,53 @@ class Model extends AbstractModel_1.AbstractModel {
             const otherlocalKey = 'id';
             const otherforeignKey = this._valuePattern(`${other}Id`);
             const localKeyPivotTable = this._valuePattern([pluralize_1.default.singular(this._tableName()), foreignKey].join("_"));
-            const sqldataChilds = [
-                `${this.$constants('SELECT')}`,
-                `*`,
-                `${this.$constants('FROM')}`,
-                `${pivotTable}`,
-                `${this.$constants('WHERE')}`,
-                `${localKeyPivotTable} ${this.$constants('IN')} (${dataPerentId})`
-            ].join(' ');
-            let dataChilds = yield this.queryStatement(sqldataChilds);
+            const sql = new Model().copyModel(modelOther)
+                .whereReference(`\`${modelOther._tableName()}\`.\`${foreignKey}\``, `\`${pivotTable}\`.\`${localKey}\``)
+                .toString();
+            const queryChildModel = new Model();
+            queryChildModel.$state.set('TABLE_NAME', `\`${pivotTable}\``);
+            const sqldataChilds = queryChildModel
+                .whereIn(localKeyPivotTable, dataPerentId)
+                .when(relation.exists, (query) => query.whereExists(sql))
+                .toString();
+            const dataChilds = yield this.queryStatement(sqldataChilds);
             const otherId = dataChilds.map((sub) => sub[otherforeignKey]).filter((data) => data != null);
             const otherArrId = Array.from(new Set(otherId)) || [];
             const otherdataChilds = yield this.queryStatement(modelOther
-                .bind(this.$pool.get())
                 .whereIn(otherlocalKey, otherArrId)
                 .debug(this.$state.get('DEBUG'))
                 .toString());
-            dataChilds.forEach((sub) => {
-                otherdataChilds.forEach((otherSub) => {
-                    if (otherSub[otherlocalKey] === sub[otherforeignKey]) {
-                        sub[other] = otherSub;
-                    }
+            if (oldVersion) {
+                dataChilds.forEach((sub) => {
+                    otherdataChilds.forEach((otherSub) => {
+                        if (otherSub[otherlocalKey] === sub[otherforeignKey]) {
+                            sub[other] = otherSub;
+                        }
+                    });
                 });
-            });
+                dataFromParent.forEach((dataPerent) => {
+                    if (dataPerent[name] == null)
+                        dataPerent[name] = [];
+                    dataChilds.forEach((sub) => {
+                        if (sub[localKeyPivotTable] === dataPerent[foreignKey]) {
+                            dataPerent[name].push(sub);
+                        }
+                    });
+                });
+                if (this.$state.get('HIDDEN').length)
+                    this._hiddenColumnModel(dataFromParent);
+                return dataFromParent;
+            }
             dataFromParent.forEach((dataPerent) => {
                 if (dataPerent[name] == null)
                     dataPerent[name] = [];
                 dataChilds.forEach((sub) => {
                     if (sub[localKeyPivotTable] === dataPerent[foreignKey]) {
-                        dataPerent[name].push(sub);
+                        const data = otherdataChilds.find(u => u[foreignKey] === sub[localKey]);
+                        if (data != null) {
+                            data.pivot = Object.assign({}, sub);
+                            dataPerent[name].push(data);
+                        }
                     }
                 });
             });
@@ -2379,10 +2396,11 @@ class Model extends AbstractModel_1.AbstractModel {
         return functionName.replace(/([A-Z])/g, (str) => `_${str.toLowerCase()}`);
     }
     _handleRelationsQuery(nameRelation, relation) {
+        var _a;
         this.$state.set('RELATION', [...this.$state.get('RELATION'), relation]);
         this.with(nameRelation);
         const r = this.$state.get('WITH').find((data) => data.name === nameRelation);
-        this._assertError(r == null, `relation ${nameRelation} not be register !`);
+        this._assertError(relation == null, `This Relation ${nameRelation} not be register in Model ${(_a = this.constructor) === null || _a === void 0 ? void 0 : _a.name}`);
         this._assertError(!Object.values(this.$constants('RELATIONSHIP')).includes(r.relation), `unknown relationship in [${this.$constants('RELATIONSHIP')}] !`);
         return r;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tspace-mysql",
-  "version": "1.2.3",
+  "version": "1.2.5",
   "description": "mysql query builder object relational mapping",
   "main": "dist/lib/index.js",
   "types": "dist/lib/index.d.ts",