tspace-mysql 1.3.8 → 1.3.9

package/README.md

@@ -414,13 +414,7 @@ class User extends Model {
      * this.useRegistry() // => build-in functions registry
      * this.useLoadRelationsInRegistry() // => auto generated results from relationship to results
      * this.useBuiltInRelationFunctions() // => build-in functions relationships to results
-     * this.useValidationSchema({
-     *   id : Number,
-     *   username : String
-     *   created_at : Date,
-     *   updated_at : Date,
-     *  }) // => validate type of schema when return results
-     * this.useCreateTableIfNotExists ({ 
+     * this.useSchema ({ 
      *     id          : new Blueprint().int().notNull().primary().autoIncrement(),
      *     uuid        : new Blueprint().varchar(50).null(),
      *     user_id     : new Blueprint().int().notNull(),
@@ -428,7 +422,9 @@ class User extends Model {
      *     created_at  : new Blueprint().timestamp().null(),
      *     updated_at  : new Blueprint().timestamp().null(),
      *     deleted_at  : new Blueprint().timestamp().null()
-     *   })
+     *  }) // auto-generated table when table is not exists and auto-create column when column not exists
+     * 
+     * this.useValidateSchema() // => validate type of value when return results reference to the schema in 'this.useSchema'
      */
 
 

package/dist/cli/generate/make.js

@@ -32,12 +32,26 @@ exports.default = (cmd) => {
         for (let i = 0; i < tables.length; i++) {
             const table = String((_a = Object.values(tables[i])) === null || _a === void 0 ? void 0 : _a.shift());
             const model = snakeCaseToPascal(pluralize_1.default.singular(table));
-            const data = (0, model_1.default)(model, npm);
-            fs.writeFile(`${cwd}/${dir}/${model}${type !== null && type !== void 0 ? type : '.ts'}`, data, (err) => {
-                if (err)
-                    throw err;
+            new lib_1.DB().rawQuery(`SHOW COLUMNS FROM ${table}`).then(raw => {
+                let schema = '';
+                for (const r of raw) {
+                    schema += `${r.Field} : `;
+                    schema += `new Blueprint().${/^[^()]*$/.test(r.Type) ? `${r.Type.toLocaleLowerCase()}()` : r.Type.toLocaleLowerCase()}`;
+                    schema += `${r.Null === 'YES' ? '.null()' : '.notNull()'}`;
+                    schema += r.Key === 'PRI' ? '.primary()' : r.Key === 'UNI' ? '.unique()' : '';
+                    schema += r.Default != null ? `.default('${r.Default}')` : '';
+                    schema += `${r.Extra === 'auto_increment' ? '.autoIncrement()' : ''},
+                    `;
+                }
+                const data = (0, model_1.default)(model, npm, `this.useSchema({
+                    ${schema.replace(/,\s*$/, "")}
+                })`);
+                fs.writeFile(`${cwd}/${dir}/${model}${type !== null && type !== void 0 ? type : '.ts'}`, data, (err) => {
+                    if (err)
+                        throw err;
+                });
+                console.log(`Model : '${model}' created successfully`);
             });
-            console.log(`Model : '${model}' created successfully`);
         }
         console.log('\nGenerate Models has completed');
     })

package/dist/cli/generate/model.d.ts

@@ -1,2 +1,2 @@
-declare const Model: (model: string, npm: string) => string;
+declare const Model: (model: string, npm: string, schema: string) => string;
 export default Model;

package/dist/cli/generate/model.js

@@ -1,26 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const Model = (model, npm) => {
-    return `import { Model } from '${npm}'
+const Model = (model, npm, schema) => {
+    return `import { Model , Blueprint } from '${npm}'
 class ${model} extends Model {
   constructor(){
     super()
-    /**
-     * 
-     * Assign setting global in your model
-     * @useMethod
-     * this.useUUID() // => runing a uuid (universally unique identifier) when insert new data
-     * this.useDebug() // debug raw query
-     * this.usePrimaryKey('id')
-     * this.useTimestamp({ createdAt : 'created_at' , updatedAt : 'updated_at' }) // runing a timestamp when insert or update
-     * this.useSoftDelete()
-     * this.useTable('users')
-     * this.useTableSingular() // 'user'
-     * this.useTablePlural() // 'users'
-     * this.usePattern('snake_case')   
-     * this.useUUID('uuid')
-     * this.useRegistry()
-    */
+      ${schema}
   }
 }
 export { ${model} }

package/dist/cli/migrate/make.d.ts

@@ -1,4 +1,4 @@
-declare const _default: (formCommand: {
+declare const _default: (commandInput: {
     [x: string]: any;
 }) => void;
 export default _default;

package/dist/cli/migrate/make.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const child_process_1 = require("child_process");
-exports.default = (formCommand) => {
+exports.default = (commandInput) => {
     var _a, _b, _c;
-    const { type, dir, cwd, fs } = formCommand;
+    const { type, dir, cwd, fs } = commandInput;
     try {
         if (dir == null)
             throw new Error('Not found directory');

package/dist/cli/models/model.js

@@ -7,7 +7,7 @@ class ${model} extends Model {
     super()
     /**
      * 
-     * Assign setting global in your model
+     * //Assign setting global in your model
      * @useMethod
      *
      * this.useDebug() 
@@ -16,19 +16,6 @@ class ${model} extends Model {
      *    createdAt : 'created_at',
      *    updatedAt : 'updated_at'
      * }) // runing a timestamp when insert or update
-     * this.useSoftDelete()
-     * this.useTable('users')
-     * this.useTableSingular() // 'user'
-     * this.useTablePlural() // 'users'
-     * 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({
-     *   id : Number,
-     *   username : String
-     *   created_at : Date,
-     *   updated_at : Date,
-     *  }) // validate type of schema when return result
     */
   }
 }

package/dist/lib/connection/options.js

@@ -18,22 +18,23 @@ const environment = () => {
     return env;
 };
 dotenv_1.default.config({ path: environment() });
+const ENV = process.env;
 const env = {
-    HOST: process.env.DB_HOST || process.env.TSPACE_HOST,
-    PORT: process.env.DB_PORT || process.env.TSPACE_PORT || 3306,
-    USERNAME: process.env.DB_USERNAME || process.env.TSPACE_USERNAME,
-    PASSWORD: process.env.DB_PASSWORD || process.env.TSPACE_PASSWORD || '',
-    DATABASE: process.env.DB_DATABASE || process.env.TSPACE_DATABASE,
-    CONNECTION_LIMIT: process.env.DB_CONNECTION_LIMIT || process.env.TSPACE_CONNECTION_LIMIT || 30,
-    QUEUE_LIMIT: process.env.DB_QUEUE_LIMIT || process.env.TSPACE_QUEUE_LIMIT || 0,
-    TIMEOUT: process.env.DB_TIMEOUT || process.env.TSPACE_TIMEOUT || 1000 * 60,
-    CHARSET: process.env.DB_CHARSET || process.env.TSPACE_CHARSET || 'utf8mb4',
-    CONNECTION_ERROR: process.env.DB_CONNECTION_ERROR || process.env.TSPACE_CONNECTION_ERROR || true,
-    WAIT_FOR_CONNECTIONS: process.env.DB_WAIT_FOR_CONNECTIONS || process.env.TSPACE_WAIT_FOR_CONNECTIONS || true,
-    DATE_STRINGS: process.env.DB_DATE_STRINGS || process.env.TSPACE_DATE_STRINGS || true,
-    KEEP_ALIVE_DELAY: process.env.DB_KEEP_ALIVE_DELAY || process.env.TSPACE_KEEP_ALIVE_DELAY || 0,
-    ENABLE_KEEP_ALIVE: process.env.DB_ENABLE_KEEP_ALIVE || process.env.TSPACE_ENABLE_KEEP_ALIVE || false,
-    MULTIPLE_STATEMENTS: process.env.MULTIPLE_STATEMENTS || process.env.TSPACE_MULTIPLE_STATEMENTS || false
+    HOST: ENV.DB_HOST || ENV.TSPACE_HOST,
+    PORT: ENV.DB_PORT || ENV.TSPACE_PORT || 3306,
+    USERNAME: ENV.DB_USERNAME || ENV.TSPACE_USERNAME,
+    PASSWORD: ENV.DB_PASSWORD || ENV.TSPACE_PASSWORD || '',
+    DATABASE: ENV.DB_DATABASE || ENV.TSPACE_DATABASE,
+    CONNECTION_LIMIT: ENV.DB_CONNECTION_LIMIT || ENV.TSPACE_CONNECTION_LIMIT || 30,
+    QUEUE_LIMIT: ENV.DB_QUEUE_LIMIT || ENV.TSPACE_QUEUE_LIMIT || 0,
+    TIMEOUT: ENV.DB_TIMEOUT || ENV.TSPACE_TIMEOUT || 1000 * 60,
+    CHARSET: ENV.DB_CHARSET || ENV.TSPACE_CHARSET || 'utf8mb4',
+    CONNECTION_ERROR: ENV.DB_CONNECTION_ERROR || ENV.TSPACE_CONNECTION_ERROR || true,
+    WAIT_FOR_CONNECTIONS: ENV.DB_WAIT_FOR_CONNECTIONS || ENV.TSPACE_WAIT_FOR_CONNECTIONS || true,
+    DATE_STRINGS: ENV.DB_DATE_STRINGS || ENV.TSPACE_DATE_STRINGS || true,
+    KEEP_ALIVE_DELAY: ENV.DB_KEEP_ALIVE_DELAY || ENV.TSPACE_KEEP_ALIVE_DELAY || 0,
+    ENABLE_KEEP_ALIVE: ENV.DB_ENABLE_KEEP_ALIVE || ENV.TSPACE_ENABLE_KEEP_ALIVE || false,
+    MULTIPLE_STATEMENTS: ENV.MULTIPLE_STATEMENTS || ENV.TSPACE_MULTIPLE_STATEMENTS || false
 };
 for (const [key, value] of Object.entries(env)) {
     if (value == null)

package/dist/lib/constants/index.js

@@ -67,6 +67,9 @@ const CONSTANTS = Object.freeze({
     CREATE_TABLE_NOT_EXISTS: 'CREATE TABLE IF NOT EXISTS',
     ENGINE: 'ENGINE=INNODB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8',
     RAND: 'RAND()',
+    ALTER_TABLE: 'ALTER TABLE',
+    ADD: 'ADD',
+    AFTER: 'AFTER',
     RELATIONSHIP: {
         hasOne: 'hasOne',
         hasMany: 'hasMany',
@@ -159,9 +162,10 @@ const CONSTANTS = Object.freeze({
             CREATED_AT: 'created_at',
             UPDATED_AT: 'updated_at'
         },
-        SCHEMA: null,
+        VALIDATE_SCHEMA: false,
+        VALIDATE_SCHEMA_DEFINED: null,
         FUNCTION_RELATION: false,
-        CREATE_TABLE: null,
+        SCHEMA_TABLE: null,
         QUERIES: 0
     }
 });

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

@@ -3,10 +3,10 @@
  * @example
  *   import { Schema , Blueprint }  from 'tspace-mysql'
  *   await new Schema().table('persos1',{
- *      id :  new Blueprint().int().notNull().primary().autoIncrement(),
- *      name : new Blueprint().varchar(255).default('my name ...'),
- *      email : new Blueprint().varchar(255).unique(),
- *      verify : new Blueprint().tinyInt(1).notNull(),
+ *      id          : new Blueprint().int().notNull().primary().autoIncrement(),
+ *      name        : new Blueprint().varchar(255).default('my name ...'),
+ *      email       : new Blueprint().varchar(255).unique(),
+ *      verify      : new Blueprint().tinyInt(1).notNull(),
  *      created_at  : new Blueprint().timestamp().null(),
  *      updated_at  : new Blueprint().timestamp().null(),
  *      deleted_at  : new Blueprint().timestamp().null()
@@ -14,7 +14,8 @@
  */
 declare class Blueprint {
     protected type: string;
-    protected attrbuites: Array<string>;
+    protected attributes: Array<string>;
+    protected valueType: NumberConstructor | StringConstructor | DateConstructor;
     /**
      * Assign type 'int' in table
      * @return {this} this
@@ -48,7 +49,7 @@ declare class Blueprint {
     float(length?: number, decimal?: number): this;
     /**
      * Assign type 'VARCHAR' in table
-     * @param {number} length  [length = 100] length of string
+     * @param {number} length  [length = 191] length of string
      * @return {this} this
      */
     varchar(length?: number): this;
@@ -65,7 +66,6 @@ declare class Blueprint {
     longText(): this;
     /**
      * Assign type 'MEDIUMTEXT' in table
-     * @param {number} length [length = 1] length of string
      * @return {this} this
      */
     mediumText(): this;
@@ -103,48 +103,48 @@ declare class Blueprint {
      */
     timestamp(): this;
     /**
-     * Assign type 'UNSIGNED' in table
+     * Assign attributes 'UNSIGNED' in table
      * @return {this} this
      */
     unsigned(): this;
     /**
-     * Assign type 'UNIQUE' in table
+     * Assign attributes 'UNIQUE' in table
      * @return {this} this
      */
     unique(): this;
     /**
-     * Assign type 'NULL' in table
+     * Assign attributes 'NULL' in table
      * @return {this} this
      */
     null(): this;
     /**
-     * Assign type 'NOT NULL' in table
+     * Assign attributes 'NOT NULL' in table
      * @return {this} this
      */
     notNull(): this;
     /**
-     * Assign type 'PRIMARY KEY' in table
+     * Assign attributes 'PRIMARY KEY' in table
      * @return {this} this
      */
     primary(): this;
     /**
-     * Assign attrbuites 'default' in table
+     * Assign attributes 'default' in table
      * @param {string | number} value  default value
      * @return {this} this
      */
     default(value: string | number): this;
     /**
-     * Assign attrbuites 'default currentTimestamp' in table
+     * Assign attributes 'default currentTimestamp' in table
      * @return {this} this
      */
     currentTimestamp(): this;
     /**
-     * Assign attrbuites 'autoIncrement' in table
+     * Assign attributes 'autoIncrement' in table
      * @return {this} this
      */
     autoIncrement(): this;
     private _addAssignType;
-    private _addAssignAttrbuite;
+    private _addAssignAttribute;
 }
 export { Blueprint };
 export default Blueprint;

package/dist/lib/tspace/Blueprint.js

@@ -6,10 +6,10 @@ exports.Blueprint = void 0;
  * @example
  *   import { Schema , Blueprint }  from 'tspace-mysql'
  *   await new Schema().table('persos1',{
- *      id :  new Blueprint().int().notNull().primary().autoIncrement(),
- *      name : new Blueprint().varchar(255).default('my name ...'),
- *      email : new Blueprint().varchar(255).unique(),
- *      verify : new Blueprint().tinyInt(1).notNull(),
+ *      id          : new Blueprint().int().notNull().primary().autoIncrement(),
+ *      name        : new Blueprint().varchar(255).default('my name ...'),
+ *      email       : new Blueprint().varchar(255).unique(),
+ *      verify      : new Blueprint().tinyInt(1).notNull(),
  *      created_at  : new Blueprint().timestamp().null(),
  *      updated_at  : new Blueprint().timestamp().null(),
  *      deleted_at  : new Blueprint().timestamp().null()
@@ -18,7 +18,8 @@ exports.Blueprint = void 0;
 class Blueprint {
     constructor() {
         this.type = '';
-        this.attrbuites = [];
+        this.attributes = [];
+        this.valueType = String;
     }
     /**
      * Assign type 'int' in table
@@ -26,6 +27,7 @@ class Blueprint {
      */
     int() {
         this._addAssignType('INT');
+        this.valueType = Number;
         return this;
     }
     /**
@@ -35,6 +37,7 @@ class Blueprint {
      */
     tinyInt(number = 1) {
         this._addAssignType(`TINYINT(${number})`);
+        this.valueType = Number;
         return this;
     }
     /**
@@ -44,6 +47,7 @@ class Blueprint {
      */
     bigInt(number = 10) {
         this._addAssignType(`BIGINT(${number})`);
+        this.valueType = Number;
         return this;
     }
     /**
@@ -53,6 +57,7 @@ class Blueprint {
      * @return {this} this
      */
     double(length = 0, decimal = 0) {
+        this.valueType = Number;
         if (!length || !decimal) {
             this._addAssignType(`DOUBLE`);
             return this;
@@ -67,6 +72,7 @@ class Blueprint {
      * @return {this} this
      */
     float(length = 0, decimal = 0) {
+        this.valueType = Number;
         if (!length || !decimal) {
             this._addAssignType(`FLOAT`);
             return this;
@@ -76,10 +82,10 @@ class Blueprint {
     }
     /**
      * Assign type 'VARCHAR' in table
-     * @param {number} length  [length = 100] length of string
+     * @param {number} length  [length = 191] length of string
      * @return {this} this
      */
-    varchar(length = 100) {
+    varchar(length = 191) {
         if (length > 255)
             length = 255;
         this._addAssignType(`VARCHAR(${length})`);
@@ -104,7 +110,6 @@ class Blueprint {
     }
     /**
      * Assign type 'MEDIUMTEXT' in table
-     * @param {number} length [length = 1] length of string
      * @return {this} this
      */
     mediumText() {
@@ -135,7 +140,7 @@ class Blueprint {
      * @return {this} this
      */
     enum(...enums) {
-        this._addAssignType(`ENUM('${enums}')`);
+        this._addAssignType(`ENUM(${enums.map(e => `'${e.replace(/'/g, '')}'`)})`);
         return this;
     }
     /**
@@ -144,6 +149,7 @@ class Blueprint {
      */
     date() {
         this._addAssignType(`DATE`);
+        this.valueType = Date;
         return this;
     }
     /**
@@ -152,6 +158,7 @@ class Blueprint {
      */
     dateTime() {
         this._addAssignType(`DATETIME`);
+        this.valueType = Date;
         return this;
     }
     /**
@@ -160,71 +167,72 @@ class Blueprint {
      */
     timestamp() {
         this._addAssignType(`TIMESTAMP`);
+        this.valueType = Date;
         return this;
     }
     /**
-     * Assign type 'UNSIGNED' in table
+     * Assign attributes 'UNSIGNED' in table
      * @return {this} this
      */
     unsigned() {
-        this._addAssignAttrbuite(`UNSIGNED`);
+        this._addAssignAttribute(`UNSIGNED`);
         return this;
     }
     /**
-     * Assign type 'UNIQUE' in table
+     * Assign attributes 'UNIQUE' in table
      * @return {this} this
      */
     unique() {
-        this._addAssignAttrbuite(`UNIQUE`);
+        this._addAssignAttribute(`UNIQUE`);
         return this;
     }
     /**
-     * Assign type 'NULL' in table
+     * Assign attributes 'NULL' in table
      * @return {this} this
      */
     null() {
-        this._addAssignAttrbuite(`NULL`);
+        this._addAssignAttribute(`NULL`);
         return this;
     }
     /**
-     * Assign type 'NOT NULL' in table
+     * Assign attributes 'NOT NULL' in table
      * @return {this} this
      */
     notNull() {
-        this._addAssignAttrbuite(`NOT NULL`);
+        this._addAssignAttribute(`NOT NULL`);
         return this;
     }
     /**
-     * Assign type 'PRIMARY KEY' in table
+     * Assign attributes 'PRIMARY KEY' in table
      * @return {this} this
      */
     primary() {
-        this._addAssignAttrbuite(`PRIMARY KEY`);
+        this._addAssignAttribute(`PRIMARY KEY`);
         return this;
     }
     /**
-     * Assign attrbuites 'default' in table
+     * Assign attributes 'default' in table
      * @param {string | number} value  default value
      * @return {this} this
      */
     default(value) {
-        this._addAssignAttrbuite(`DEFAULT '${value}'`);
+        this._addAssignAttribute(`DEFAULT '${value}'`);
         return this;
     }
     /**
-     * Assign attrbuites 'default currentTimestamp' in table
+     * Assign attributes 'default currentTimestamp' in table
      * @return {this} this
      */
     currentTimestamp() {
-        this._addAssignAttrbuite(`DEFAULT CURRENT_TIMESTAMP`);
+        this._addAssignAttribute(`DEFAULT CURRENT_TIMESTAMP`);
         return this;
     }
     /**
-     * Assign attrbuites 'autoIncrement' in table
+     * Assign attributes 'autoIncrement' in table
      * @return {this} this
      */
     autoIncrement() {
-        this._addAssignAttrbuite(`AUTO_INCREMENT`);
+        this._addAssignAttribute(`AUTO_INCREMENT`);
         return this;
     }
     _addAssignType(type) {
@@ -233,8 +241,8 @@ class Blueprint {
         this.type = type;
         return this;
     }
-    _addAssignAttrbuite(attrbuite) {
-        this.attrbuites = [...this.attrbuites, attrbuite];
+    _addAssignAttribute(Attribute) {
+        this.attributes = [...this.attributes, Attribute];
         return this;
     }
 }

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

@@ -783,6 +783,12 @@ declare class Builder extends AbstractBuilder {
      * @return {Promise<Array>}
      */
     showSchemas(table?: string): Promise<Array<string>>;
+    /**
+     *
+     * get schema from table
+     * @return {this} this this
+     */
+    getSchema(): Promise<any>;
     /**
      *
      * show values in table

package/dist/lib/tspace/Builder.js

@@ -2077,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/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
@@ -1016,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;
     }
     /**
@@ -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
@@ -1707,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);
         });
     }
     /**
@@ -1989,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;
                 }
@@ -2018,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;
@@ -2845,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;

package/dist/lib/tspace/Schema.js

@@ -20,10 +20,10 @@ class Schema extends Builder_1.Builder {
                 let columns = [];
                 for (const key in schemas) {
                     const data = schemas[key];
-                    const { type, attrbuites } = data;
+                    const { type, attributes } = data;
                     columns = [
                         ...columns,
-                        `${key} ${type} ${attrbuites === null || attrbuites === void 0 ? void 0 : attrbuites.join(' ')}`
+                        `${key} ${type} ${attributes === null || attributes === void 0 ? void 0 : attributes.join(' ')}`
                     ];
                 }
                 const sql = [
@@ -39,14 +39,14 @@ class Schema extends Builder_1.Builder {
                 console.log((_a = err.message) === null || _a === void 0 ? void 0 : _a.replace(/ER_TABLE_EXISTS_ERROR:/g, ""));
             }
         });
-        this.createTable = (table, schemas) => __awaiter(this, void 0, void 0, function* () {
+        this.createTable = (table, schemas) => {
             let columns = [];
             for (const key in schemas) {
                 const data = schemas[key];
-                const { type, attrbuites } = data;
+                const { type, attributes } = data;
                 columns = [
                     ...columns,
-                    `${key} ${type} ${attrbuites === null || attrbuites === void 0 ? void 0 : attrbuites.join(' ')}`
+                    `${key} ${type} ${attributes === null || attributes === void 0 ? void 0 : attributes.join(' ')}`
                 ];
             }
             const sql = [
@@ -54,8 +54,8 @@ class Schema extends Builder_1.Builder {
                 `${table} (${columns === null || columns === void 0 ? void 0 : columns.join(', ')})`,
                 `ENGINE=INNODB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8`
             ].join(' ');
-            return yield this.rawQuery(sql);
-        });
+            return sql;
+        };
     }
 }
 exports.Schema = Schema;

package/package.json

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