tspace-mysql 1.2.2 → 1.2.4

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({
@@ -640,7 +640,7 @@ hook((result) => ...) // callback result to function
 hasOne({ name , model , localKey , foreignKey , freezeTable , as })
 hasMany({ name , model , localKey , foreignKey , freezeTable , as })
 belongsTo({ name , model , localKey , foreignKey , freezeTable , as })
-belongsToMany({ name , model , localKey , foreignKey , freezeTable , as })
+belongsToMany({ name , model , localKey , foreignKey , freezeTable , as , pivot })
 /** 
  * @relation using registry in your models
 */

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,7 @@ export interface Relation {
     pivot?: string | undefined;
     query?: any | undefined;
     relation?: Object | undefined;
+    exists?: 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 }: Relation): this;
+    protected belongsToMany({ name, as, model, localKey, foreignKey, freezeTable, pivot }: Relation): this;
     /**
      * Assign the relation in model Objects
      * @param    {object}  relation registry relation in your model
@@ -287,7 +287,7 @@ declare class Model extends AbstractModel {
      * @param    {function?} callback callback of query
      * @return   {this} this
      */
-    protected belongsToManyBuilder({ name, as, model, localKey, foreignKey, freezeTable }: RelationQuery, callback?: Function): this;
+    protected belongsToManyBuilder({ name, as, model, localKey, foreignKey, freezeTable, pivot }: RelationQuery, callback?: Function): this;
     /**
      * return only in trashed (data has been remove)
      * @return {promise}

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 }) {
+    belongsToMany({ name, as, model, localKey, foreignKey, freezeTable, pivot }) {
         const relation = {
             name,
             model,
@@ -462,6 +453,7 @@ class Model extends AbstractModel_1.AbstractModel {
             localKey,
             foreignKey,
             freezeTable,
+            pivot,
             query: null
         };
         this.$state.set('RELATION', [...this.$state.get('RELATION'), relation]);
@@ -585,7 +577,7 @@ class Model extends AbstractModel_1.AbstractModel {
      * @param    {function?} callback callback of query
      * @return   {this} this
      */
-    belongsToManyBuilder({ name, as, model, localKey, foreignKey, freezeTable }, callback) {
+    belongsToManyBuilder({ name, as, model, localKey, foreignKey, freezeTable, pivot }, callback) {
         const nameRelation = name == null
             ? this._functionRelationName()
             : String(name);
@@ -597,6 +589,7 @@ class Model extends AbstractModel_1.AbstractModel {
             localKey,
             foreignKey,
             freezeTable,
+            pivot,
             query: null
         };
         const r = this._handleRelationsQuery(nameRelation, relation);
@@ -1598,23 +1591,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* () {
@@ -1719,6 +1716,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}']`);
@@ -1732,13 +1731,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("_"))}\``)
@@ -1784,7 +1783,7 @@ class Model extends AbstractModel_1.AbstractModel {
     _belongsToMany(dataFromParent, relation) {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
-            const { name, localKey, foreignKey, pivot } = this._valueInRelation(relation);
+            const { name, foreignKey, pivot } = this._valueInRelation(relation);
             const pivotTable = String(((_a = relation.pivot) !== null && _a !== void 0 ? _a : pivot));
             const localKeyId = dataFromParent.map((parent) => {
                 const data = parent[foreignKey];
@@ -2377,10 +2376,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.2",
+  "version": "1.2.4",
   "description": "mysql query builder object relational mapping",
   "main": "dist/lib/index.js",
   "types": "dist/lib/index.d.ts",