tspace-mysql 1.3.7 → 1.3.9

package/dist/lib/tspace/Builder.js

@@ -300,9 +300,9 @@ class Builder extends AbstractBuilder_1.AbstractBuilder {
     whereIn(column, array) {
         if (!Array.isArray(array))
             throw new Error(`[${array}] is't array`);
-        if (!array.length)
-            return this;
-        const values = `${array.map((value) => this._checkValueHasRaw(this.$utils.escape(value))).join(',')}`;
+        const values = array.length
+            ? `${array.map((value) => this._checkValueHasRaw(this.$utils.escape(value))).join(',')}`
+            : this.$constants('NULL');
         this.$state.set('WHERE', [
             this._queryWhereIsExists()
                 ? `${this.$state.get('WHERE')} ${this.$constants('AND')}`
@@ -322,9 +322,9 @@ class Builder extends AbstractBuilder_1.AbstractBuilder {
     orWhereIn(column, array) {
         if (!Array.isArray(array))
             throw new Error(`[${array}] is't array`);
-        if (!array.length)
-            return this;
-        const values = `${array.map((value) => this._checkValueHasRaw(this.$utils.escape(value))).join(',')}`;
+        const values = array.length
+            ? `${array.map((value) => this._checkValueHasRaw(this.$utils.escape(value))).join(',')}`
+            : this.$constants('NULL');
         this.$state.set('WHERE', [
             this._queryWhereIsExists()
                 ? `${this.$state.get('WHERE')} ${this.$constants('OR')}`
@@ -345,9 +345,9 @@ class Builder extends AbstractBuilder_1.AbstractBuilder {
         const sql = this.$state.get('WHERE');
         if (!Array.isArray(array))
             throw new Error(`[${array}] is't array`);
-        if (!array.length)
-            return this;
-        const values = `${array.map((value) => this._checkValueHasRaw(this.$utils.escape(value))).join(',')}`;
+        const values = array.length
+            ? `${array.map((value) => this._checkValueHasRaw(this.$utils.escape(value))).join(',')}`
+            : this.$constants('NULL');
         this.$state.set('WHERE', [
             this._queryWhereIsExists()
                 ? `${this.$state.get('WHERE')} ${this.$constants('AND')}`
@@ -367,9 +367,9 @@ class Builder extends AbstractBuilder_1.AbstractBuilder {
     orWhereNotIn(column, array) {
         if (!Array.isArray(array))
             throw new Error(`[${array}] is't array`);
-        if (!array.length)
-            return this;
-        const values = `${array.map((value) => this._checkValueHasRaw(this.$utils.escape(value))).join(',')}`;
+        const values = array.length
+            ? `${array.map((value) => this._checkValueHasRaw(this.$utils.escape(value))).join(',')}`
+            : this.$constants('NULL');
         this.$state.set('WHERE', [
             this._queryWhereIsExists()
                 ? `${this.$state.get('WHERE')} ${this.$constants('OR')}`
@@ -387,6 +387,8 @@ class Builder extends AbstractBuilder_1.AbstractBuilder {
      * @return {this}
      */
     whereSubQuery(column, subQuery) {
+        if (!this.$utils.isQuery(subQuery))
+            throw new Error(`This "${subQuery}" is invalid sub query`);
         this.$state.set('WHERE', [
             this._queryWhereIsExists()
                 ? `${this.$state.get('WHERE')} ${this.$constants('AND')}`
@@ -404,6 +406,8 @@ class Builder extends AbstractBuilder_1.AbstractBuilder {
      * @return {this}
      */
     whereNotSubQuery(column, subQuery) {
+        if (!this.$utils.isQuery(subQuery))
+            throw new Error(`This "${subQuery}" is invalid sub query`);
         this.$state.set('WHERE', [
             this._queryWhereIsExists()
                 ? `${this.$state.get('WHERE')} ${this.$constants('AND')}`
@@ -421,6 +425,8 @@ class Builder extends AbstractBuilder_1.AbstractBuilder {
      * @return {this}
      */
     orWhereSubQuery(column, subQuery) {
+        if (!this.$utils.isQuery(subQuery))
+            throw new Error(`This "${subQuery}" is invalid sub query`);
         this.$state.set('WHERE', [
             this._queryWhereIsExists()
                 ? `${this.$state.get('WHERE')} ${this.$constants('OR')}`
@@ -438,6 +444,8 @@ class Builder extends AbstractBuilder_1.AbstractBuilder {
      * @return {this}
      */
     orWhereNotSubQuery(column, subQuery) {
+        if (!this.$utils.isQuery(subQuery))
+            throw new Error(`This "${subQuery}" is invalid sub query`);
         this.$state.set('WHERE', [
             this._queryWhereIsExists()
                 ? `${this.$state.get('WHERE')} ${this.$constants('OR')}`
@@ -457,8 +465,16 @@ class Builder extends AbstractBuilder_1.AbstractBuilder {
     whereBetween(column, array) {
         if (!Array.isArray(array))
             throw new Error("Value is't array");
-        if (!array.length)
+        if (!array.length) {
+            this.$state.set('WHERE', [
+                this._queryWhereIsExists()
+                    ? `${this.$state.get('WHERE')} ${this.$constants('AND')}`
+                    : `${this.$constants('WHERE')}`,
+                `${this._bindTableAndColumnInQueryWhere(column)} ${this.$constants('BETWEEN')}`,
+                `${this.$constants('NULL')} ${this.$constants('AND')} ${this.$constants('NULL')}`
+            ].join(' '));
             return this;
+        }
         const [value1, value2] = array;
         this.$state.set('WHERE', [
             this._queryWhereIsExists()
@@ -478,8 +494,16 @@ class Builder extends AbstractBuilder_1.AbstractBuilder {
     orWhereBetween(column, array) {
         if (!Array.isArray(array))
             throw new Error("Value is't array");
-        if (!array.length)
+        if (!array.length) {
+            this.$state.set('WHERE', [
+                this._queryWhereIsExists()
+                    ? `${this.$state.get('WHERE')} ${this.$constants('OR')}`
+                    : `${this.$constants('WHERE')}`,
+                `${this._bindTableAndColumnInQueryWhere(column)} ${this.$constants('BETWEEN')}`,
+                `${this.$constants('NULL')} ${this.$constants('AND')} ${this.$constants('NULL')}`
+            ].join(' '));
             return this;
+        }
         const [value1, value2] = array;
         this.$state.set('WHERE', [
             this._queryWhereIsExists()
@@ -499,8 +523,16 @@ class Builder extends AbstractBuilder_1.AbstractBuilder {
     whereNotBetween(column, array) {
         if (!Array.isArray(array))
             throw new Error("Value is't array");
-        if (!array.length)
+        if (!array.length) {
+            this.$state.set('WHERE', [
+                this._queryWhereIsExists()
+                    ? `${this.$state.get('WHERE')} ${this.$constants('AND')}`
+                    : `${this.$constants('WHERE')}`,
+                `${this._bindTableAndColumnInQueryWhere(column)} ${this.$constants('NOT_BETWEEN')}`,
+                `${this.$constants('NULL')} ${this.$constants('AND')} ${this.$constants('NULL')}`
+            ].join(' '));
             return this;
+        }
         const [value1, value2] = array;
         this.$state.set('WHERE', [
             this._queryWhereIsExists()
@@ -511,6 +543,35 @@ class Builder extends AbstractBuilder_1.AbstractBuilder {
         ].join(' '));
         return this;
     }
+    /**
+     * where not between using [value1, value2]
+     * @param {string} column
+     * @param {array} array
+     * @return {this}
+     */
+    orWhereNotBetween(column, array) {
+        if (!Array.isArray(array))
+            throw new Error("Value is't array");
+        if (!array.length) {
+            this.$state.set('WHERE', [
+                this._queryWhereIsExists()
+                    ? `${this.$state.get('WHERE')} ${this.$constants('OR')}`
+                    : `${this.$constants('WHERE')}`,
+                `${this._bindTableAndColumnInQueryWhere(column)} ${this.$constants('NOT_BETWEEN')}`,
+                `${this.$constants('NULL')} ${this.$constants('AND')} ${this.$constants('NULL')}`
+            ].join(' '));
+            return this;
+        }
+        const [value1, value2] = array;
+        this.$state.set('WHERE', [
+            this._queryWhereIsExists()
+                ? `${this.$state.get('WHERE')} ${this.$constants('OR')}`
+                : `${this.$constants('WHERE')}`,
+            `${this._bindTableAndColumnInQueryWhere(column)} ${this.$constants('NOT_BETWEEN')}`,
+            `${this._checkValueHasRaw(this.$utils.escape(value1))} ${this.$constants('AND')} ${this._checkValueHasRaw(this.$utils.escape(value2))}`
+        ].join(' '));
+        return this;
+    }
     /**
      * where null using NULL
      * @param {string} column
@@ -2016,6 +2077,22 @@ class Builder extends AbstractBuilder_1.AbstractBuilder {
             });
         });
     }
+    /**
+     *
+     * get schema from table
+     * @return {this} this this
+     */
+    getSchema() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const sql = [
+                `${this.$constants('SHOW')}`,
+                `${this.$constants('COLUMNS')}`,
+                `${this.$constants('FROM')}`,
+                `\`${this.$state.get('TABLE_NAME').replace(/\`/g, '')}\``
+            ].join(' ');
+            return yield this.queryStatement(sql);
+        });
+    }
     /**
      *
      * show values in table

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

@@ -9,6 +9,7 @@ export interface Relation {
     query?: any | undefined;
     relation?: Object | undefined;
     exists?: boolean | undefined;
+    all?: boolean | undefined;
     trashed?: boolean | undefined;
     oldVersion?: boolean | undefined;
 }

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

@@ -40,7 +40,7 @@ declare class Model extends AbstractModel {
      * import { Blueprint } from 'tspace-mysql'
      * class User extends Model {
      *     constructor() {
-     *        this.useCreateTableIfNotExists ({
+     *        this.useSchema ({
      *            id          : new Blueprint().int().notNull().primary().autoIncrement(),
      *            uuid        : new Blueprint().varchar(50).null(),
      *            email       : new Blueprint().varchar(50).null(),
@@ -52,7 +52,7 @@ declare class Model extends AbstractModel {
      * }
      * @return {this} this
      */
-    protected useCreateTableIfNotExists(schema: Record<string, any>): this;
+    protected useSchema(schema: Record<string, any>): this;
     /**
      *
      * Assign function callback in model like constructor()
@@ -211,17 +211,25 @@ declare class Model extends AbstractModel {
      * @example
      * class User extends Model {
      *   constructor() {
-     *     this.useValidationSchema({
-     *        id       : Number,
-     *        email    : String,
-     *        name     : String,
-     *        date     : Date
-     *     })
+     *     this.useValidationSchema()
      *   }
      * }
      * @return {this} this
      */
-    protected useValidationSchema(schema: Record<string, NumberConstructor | StringConstructor | DateConstructor>): this;
+    protected useValidationSchema(schema?: null | Record<string, NumberConstructor | StringConstructor | DateConstructor>): this;
+    /**
+    *
+    * Assign schema column in model for validation data types
+    * @param {Object<NumberConstructor | StringConstructor | DateConstructor>} schema types (String Number and Date)
+    * @example
+    * class User extends Model {
+    *   constructor() {
+    *     this.useValidationSchema()
+    *   }
+    * }
+    * @return {this} this
+    */
+    protected useValidateSchema(schema?: null | Record<string, NumberConstructor | StringConstructor | DateConstructor>): this;
     /**
      * Assign hook function when execute returned results to callback function
      * @param {Array<Function>} arrayFunctions functions for callback result
@@ -342,11 +350,18 @@ declare class Model extends AbstractModel {
     with(...nameRelations: Array<string>): this;
     /**
      *
-     * Use relations in registry of model return normal and in trash
+     * Use relations in registry of model return ignore soft delete
+     * @param {...string} nameRelations if data exists return blank
+     * @return {this} this
+     */
+    withAll(...nameRelations: Array<string>): this;
+    /**
+     *
+     * Use relations in registry of model return only in trash (soft delete)
      * @param {...string} nameRelations if data exists return blank
      * @return {this} this
      */
-    withAndTrashed(...nameRelations: Array<string>): this;
+    withTrashed(...nameRelations: Array<string>): this;
     /**
      *
      * Use relations in registry of model return only exists result of relation query
@@ -547,7 +562,14 @@ declare class Model extends AbstractModel {
      * @param {...string} nameRelations if data exists return blank
      * @return {this} this
      */
-    relationsAndTrashed(...nameRelations: Array<string>): this;
+    relationsAll(...nameRelations: Array<string>): this;
+    /**
+     *
+     * Use relations in registry of model return only in trash (soft delete)
+     * @param {...string} nameRelations if data exists return blank
+     * @return {this} this
+     */
+    relationsTrashed(...nameRelations: Array<string>): this;
     /**
      * Assign the relation in model Objects
      * @param    {object} relations registry relation in your model
@@ -654,6 +676,12 @@ declare class Model extends AbstractModel {
      * @return   {this} this
      */
     protected belongsToManyBuilder({ name, as, model, localKey, foreignKey, freezeTable, pivot }: RelationQuery, callback?: Function): this;
+    /**
+     * where not null using NULL
+     * @override
+     * @return {this}
+     */
+    whereTrashed(): this;
     /**
      * return only in trashed (data has been remove)
      * @return {promise}
@@ -996,7 +1024,7 @@ declare class Model extends AbstractModel {
     private _handleRelations;
     private _handleRelationsQuery;
     private _validateMethod;
-    private _tryToCreateTable;
+    private _checkSchemaOrNextError;
     private _initialModel;
 }
 export { Model };

package/dist/lib/tspace/Model.js

@@ -73,7 +73,7 @@ class Model extends AbstractModel_1.AbstractModel {
      * import { Blueprint } from 'tspace-mysql'
      * class User extends Model {
      *     constructor() {
-     *        this.useCreateTableIfNotExists ({
+     *        this.useSchema ({
      *            id          : new Blueprint().int().notNull().primary().autoIncrement(),
      *            uuid        : new Blueprint().varchar(50).null(),
      *            email       : new Blueprint().varchar(50).null(),
@@ -85,8 +85,8 @@ class Model extends AbstractModel_1.AbstractModel {
      * }
      * @return {this} this
      */
-    useCreateTableIfNotExists(schema) {
-        this.$state.set('CREATE_TABLE', schema);
+    useSchema(schema) {
+        this.$state.set('SCHEMA_TABLE', schema);
         return this;
     }
     /**
@@ -194,7 +194,7 @@ class Model extends AbstractModel_1.AbstractModel {
             this.$constants('PATTERN').snake_case,
             this.$constants('PATTERN').camelCase
         ];
-        this._assertError(!allowPattern.includes(pattern), `tspace-mysql support only pattern [${allowPattern}]`);
+        this._assertError(!allowPattern.includes(pattern), `tspace-mysql support only pattern ["${this.$constants('PATTERN').snake_case}","${this.$constants('PATTERN').camelCase}"]`);
         this.$state.set('PATTERN', pattern);
         return this;
     }
@@ -301,18 +301,31 @@ class Model extends AbstractModel_1.AbstractModel {
      * @example
      * class User extends Model {
      *   constructor() {
-     *     this.useValidationSchema({
-     *        id       : Number,
-     *        email    : String,
-     *        name     : String,
-     *        date     : Date
-     *     })
+     *     this.useValidationSchema()
      *   }
      * }
      * @return {this} this
      */
     useValidationSchema(schema) {
-        this.$state.set('SCHEMA', schema);
+        this.$state.set('VALIDATE_SCHEMA', true);
+        this.$state.set('VALIDATE_SCHEMA_DEFINED', schema);
+        return this;
+    }
+    /**
+    *
+    * Assign schema column in model for validation data types
+    * @param {Object<NumberConstructor | StringConstructor | DateConstructor>} schema types (String Number and Date)
+    * @example
+    * class User extends Model {
+    *   constructor() {
+    *     this.useValidationSchema()
+    *   }
+    * }
+    * @return {this} this
+    */
+    useValidateSchema(schema) {
+        this.$state.set('VALIDATE_SCHEMA', true);
+        this.$state.set('VALIDATE_SCHEMA_DEFINED', schema);
         return this;
     }
     /**
@@ -340,8 +353,8 @@ class Model extends AbstractModel_1.AbstractModel {
      */
     exceptColumns() {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this.$state.get('SCHEMA')) {
-                const columns = Object.keys(this.$state.get('SCHEMA'));
+            if (this.$state.get('SCHEMA_TABLE')) {
+                const columns = Object.keys(this.$state.get('SCHEMA_TABLE'));
                 const removeExcept = columns.filter((column) => {
                     const excepts = this.$state.get('EXCEPT');
                     return excepts.every((except) => except !== column);
@@ -437,7 +450,7 @@ class Model extends AbstractModel_1.AbstractModel {
                 return result;
             }
             catch (e) {
-                yield this._tryToCreateTable(e);
+                yield this._checkSchemaOrNextError(e);
                 return yield this.queryStatement(sql);
             }
         });
@@ -465,7 +478,7 @@ class Model extends AbstractModel_1.AbstractModel {
                 return result;
             }
             catch (e) {
-                yield this._tryToCreateTable(e);
+                yield this._checkSchemaOrNextError(e);
                 return yield this.actionStatement({
                     sql,
                     returnId
@@ -549,11 +562,32 @@ class Model extends AbstractModel_1.AbstractModel {
     }
     /**
      *
-     * Use relations in registry of model return normal and in trash
+     * Use relations in registry of model return ignore soft delete
      * @param {...string} nameRelations if data exists return blank
      * @return {this} this
      */
-    withAndTrashed(...nameRelations) {
+    withAll(...nameRelations) {
+        const relations = this._handleRelations(nameRelations);
+        relations.forEach(relation => relation.all = true);
+        const setRelations = this.$state.get('RELATIONS').length
+            ? [...relations.map((w) => {
+                    const exists = this.$state.get('RELATIONS').find((r) => r.name === w.name);
+                    if (exists)
+                        return null;
+                    return w;
+                }).filter((d) => d != null),
+                ...this.$state.get('RELATIONS')]
+            : relations;
+        this.$state.set('RELATIONS', setRelations);
+        return this;
+    }
+    /**
+     *
+     * Use relations in registry of model return only in trash (soft delete)
+     * @param {...string} nameRelations if data exists return blank
+     * @return {this} this
+     */
+    withTrashed(...nameRelations) {
         const relations = this._handleRelations(nameRelations);
         relations.forEach(relation => relation.trashed = true);
         const setRelations = this.$state.get('RELATIONS').length
@@ -799,8 +833,17 @@ class Model extends AbstractModel_1.AbstractModel {
      * @param {...string} nameRelations if data exists return blank
      * @return {this} this
      */
-    relationsAndTrashed(...nameRelations) {
-        return this.withAndTrashed(...nameRelations);
+    relationsAll(...nameRelations) {
+        return this.withAll(...nameRelations);
+    }
+    /**
+     *
+     * Use relations in registry of model return only in trash (soft delete)
+     * @param {...string} nameRelations if data exists return blank
+     * @return {this} this
+     */
+    relationsTrashed(...nameRelations) {
+        return this.withTrashed(...nameRelations);
     }
     /**
      * Assign the relation in model Objects
@@ -1047,6 +1090,16 @@ class Model extends AbstractModel_1.AbstractModel {
         r.query = callback(new r.model());
         return this;
     }
+    /**
+     * where not null using NULL
+     * @override
+     * @return {this}
+     */
+    whereTrashed() {
+        this.disableSoftDelete();
+        this.whereNotNull(this._valuePattern(this.$state.get('SOFT_DELETE_FORMAT')));
+        return this;
+    }
     /**
      * return only in trashed (data has been remove)
      * @return {promise}
@@ -1667,44 +1720,7 @@ class Model extends AbstractModel_1.AbstractModel {
                 `${this.$constants('FROM')}`,
                 `\`${this.$state.get('TABLE_NAME').replace(/\`/g, '')}\``
             ].join(' ');
-            const raw = yield this.queryStatement(sql);
-            const schemas = raw.map((r) => {
-                let schema = { [r.Field]: String };
-                const numberLists = [
-                    'tinyint',
-                    'smallint',
-                    'mediumint',
-                    'int',
-                    'bigint',
-                    'float',
-                    'double',
-                    'decimal',
-                    'real',
-                    'bit',
-                    'boolean',
-                    'serial'
-                ];
-                const dateAndTimeLists = [
-                    'date',
-                    'datetime',
-                    'time',
-                    'timestamp',
-                    'year'
-                ];
-                if (numberLists.includes(r.Type)) {
-                    schema = {
-                        [r.Field]: Number
-                    };
-                }
-                if (dateAndTimeLists.includes(r.Type)) {
-                    schema = {
-                        [r.Field]: Date
-                    };
-                }
-                return schema;
-            });
-            const result = Object.assign({}, ...schemas);
-            return result;
+            return yield this.queryStatement(sql);
         });
     }
     /**
@@ -1949,27 +1965,37 @@ class Model extends AbstractModel_1.AbstractModel {
         return result;
     }
     _validateSchema(results) {
-        const schema = this.$state.get('SCHEMA');
-        if (schema == null)
-            return;
         if (!results.length)
             return;
+        const validateSchema = Boolean(this.$state.get('VALIDATE_SCHEMA'));
+        if (!validateSchema)
+            return;
+        const schemaTable = this.$state.get('SCHEMA_TABLE');
+        const schemaTableDefined = this.$state.get('VALIDATE_SCHEMA_DEFINED');
+        this._assertError(schemaTableDefined == null && schemaTable == null, "Can't validate schema withouted schema");
+        const schema = schemaTableDefined !== null && schemaTableDefined !== void 0 ? schemaTableDefined : Object.keys(schemaTable).reduce((acc, key) => {
+            acc[key] = schemaTable[key].valueType;
+            return acc;
+        }, {});
+        if (schema == null)
+            return;
         const typeOf = (data) => Object.prototype.toString.apply(data).slice(8, -1).toLocaleLowerCase();
         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]/;
-        const selectedAll = this.$state.get('SELECT').replace('SELECT', '').trim() === '*';
+        const select = this.$state.get('SELECT');
+        const selectedAll = select.replace('SELECT', '').trim() === '*';
         for (const result of results) {
             const schemaKeys = Object.keys(schema);
             const resultKeys = Object.keys(result);
             if (schemaKeys.some(s => !resultKeys.includes(s)) && selectedAll) {
                 const columns = schemaKeys.filter(x => !resultKeys.includes(x));
-                this._assertError(`Not found this column [ ${columns.join(', ')} ] in result`);
+                this._assertError(`Not found this column "${columns.join(', ')}" in result`);
             }
             for (const column in result) {
                 const s = schema[column];
                 if (s == null && selectedAll) {
                     if (!schemaKeys.every(s => resultKeys.includes(s))) {
-                        this._assertError(`Not found this column [ ${column} ] in result`);
+                        this._assertError(`Not found this column "${column}" in result`);
                     }
                     continue;
                 }
@@ -1978,13 +2004,13 @@ class Model extends AbstractModel_1.AbstractModel {
                 if (regexDate.test(result[column]) || regexDateTime.test(result[column])) {
                     if (typeOf(new Date(result[column])) === typeOf(new s()))
                         continue;
-                    this._assertError(`This column [ ${column} ] is invalid schema field type`);
+                    this._assertError(`This column "${column}" is invalid schema field type`);
                 }
                 if (result[column] == null)
                     continue;
                 if (typeOf(result[column]) === typeOf(new s()))
                     continue;
-                this._assertError(`This column [ ${column} ] is invalid schema field type`);
+                this._assertError(`This column "${column}" is invalid schema field type`);
             }
         }
         return;
@@ -2152,7 +2178,8 @@ class Model extends AbstractModel_1.AbstractModel {
                 .bind(this.$pool.get())
                 .whereIn(foreignKey, dataPerentId)
                 .debug(this.$state.get('DEBUG'))
-                .when(relation.trashed, (query) => query.disableSoftDelete())
+                .when(relation.trashed, (query) => query.whereTrashed())
+                .when(relation.all, (query) => query.disableSoftDelete())
                 .get();
             return dataFromRelation;
         });
@@ -2185,7 +2212,8 @@ class Model extends AbstractModel_1.AbstractModel {
             const sqldataChilds = queryChildModel
                 .whereIn(localKeyPivotTable, dataPerentId)
                 .when(relation.exists, (query) => query.whereExists(sql))
-                .when(relation.trashed, (query) => query.disableSoftDelete())
+                .when(relation.trashed, (query) => query.whereTrashed())
+                .when(relation.all, (query) => query.disableSoftDelete())
                 .toString();
             const dataChilds = yield this.queryStatement(sqldataChilds);
             const otherId = dataChilds.map((sub) => sub[otherforeignKey]).filter((data) => data != null);
@@ -2803,23 +2831,48 @@ class Model extends AbstractModel_1.AbstractModel {
             }
         }
     }
-    _tryToCreateTable(e) {
-        var _a;
+    _checkSchemaOrNextError(e) {
+        var _a, _b, _c, _d, _e;
         return __awaiter(this, void 0, void 0, function* () {
-            const createTable = this.$state.get('CREATE_TABLE');
-            if (createTable == null)
-                throw e;
-            const errorMessage = (_a = e === null || e === void 0 ? void 0 : e.message) !== null && _a !== void 0 ? _a : '';
-            const errorWhenTableIsNotExists = "doesn't exist";
-            if (!errorMessage.toLocaleLowerCase().includes(errorWhenTableIsNotExists))
-                throw e;
-            if (this.$state.get('QUERIES') > 3)
-                throw e;
             try {
+                if (this.$state.get('QUERIES') > 3)
+                    throw e;
+                const schemaTable = this.$state.get('SCHEMA_TABLE');
+                if (schemaTable == null)
+                    throw e;
+                const errorMessage = (_a = e === null || e === void 0 ? void 0 : e.message) !== null && _a !== void 0 ? _a : '';
+                if (errorMessage.toLocaleLowerCase().includes('unknown column')) {
+                    const pattern = /'([^']+)'/;
+                    const column = errorMessage.match(pattern)
+                        ? String(errorMessage.match(pattern)[0]).replace(/'/g, '').split('.').pop()
+                        : null;
+                    if (column == null)
+                        throw e;
+                    const type = (_c = (_b = schemaTable[column]) === null || _b === void 0 ? void 0 : _b.type) !== null && _c !== void 0 ? _c : null;
+                    const attributes = (_e = (_d = schemaTable[column]) === null || _d === void 0 ? void 0 : _d.attributes) !== null && _e !== void 0 ? _e : null;
+                    if (type == null || attributes == null)
+                        throw e;
+                    const entries = Object.entries(schemaTable);
+                    const indexWithColumn = entries.findIndex(([key]) => key === column);
+                    const findAfterIndex = indexWithColumn ? entries[indexWithColumn - 1][0] : null;
+                    if (findAfterIndex == null)
+                        throw e;
+                    const sql = [
+                        `${this.$constants('ALTER_TABLE')}`,
+                        `${this.$state.get('TABLE_NAME')}`,
+                        `${this.$constants('ADD')}`,
+                        `\`${column}\` ${type} ${attributes.join(' ')}`,
+                        `${this.$constants('AFTER')} \`${findAfterIndex !== null && findAfterIndex !== void 0 ? findAfterIndex : ''}\``
+                    ].join(' ');
+                    yield this.queryStatement(sql);
+                    return;
+                }
+                if (!errorMessage.toLocaleLowerCase().includes("doesn't exist"))
+                    throw e;
                 const tableName = this.$state.get('TABLE_NAME');
-                yield new Schema_1.Schema()
-                    .debug(this.$state.get('DEBUG'))
-                    .createTable(tableName, createTable);
+                const sql = new Schema_1.Schema().createTable(tableName, schemaTable);
+                yield this.queryStatement(sql);
+                return;
             }
             catch (e) {
                 throw e;

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

@@ -1,7 +1,7 @@
 import { Builder } from "./Builder";
 declare class Schema extends Builder {
     table: (table: string, schemas: Record<string, any>) => Promise<void>;
-    createTable: (table: string, schemas: Record<string, any>) => Promise<any>;
+    createTable: (table: string, schemas: Record<string, any>) => string;
 }
 export { Schema };
 export default Schema;