tspace-mysql 1.3.8 → 1.4.0

package/dist/lib/tspace/DB.js

@@ -161,13 +161,34 @@ class DB extends AbstractDB_1.AbstractDB {
      * @return {Connection}
      */
     getConnection(options) {
-        const { host, port, database, username: user, password } = options, others = __rest(options, ["host", "port", "database", "username", "password"]);
-        const pool = new connection_1.PoolConnection(Object.assign({ host,
-            port,
-            database,
-            user,
-            password }, others));
-        return pool.connection();
+        return __awaiter(this, void 0, void 0, function* () {
+            if (options == null) {
+                const pool = yield this.$pool.get();
+                return yield pool.connection();
+            }
+            const { host, port, database, username: user, password } = options, others = __rest(options, ["host", "port", "database", "username", "password"]);
+            const pool = new connection_1.PoolConnection(Object.assign({ host,
+                port,
+                database,
+                user,
+                password }, others));
+            return yield pool.connection();
+        });
+    }
+    /**
+     * Get a connection
+     * @return {ConnectionTransaction} object - Connection for the transaction
+     * @type     {object} connection
+     * @property {function} connection.query - execute query sql then release connection to pool
+     * @property {function} connection.startTransaction - start transaction of query
+     * @property {function} connection.commit - commit transaction of query
+     * @property {function} connection.rollback - rollback transaction of query
+     */
+    beginTransaction() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const pool = yield this.$pool.get();
+            return yield pool.connection();
+        });
     }
     /**
      * Covert result to array
@@ -217,21 +238,6 @@ class DB extends AbstractDB_1.AbstractDB {
             };
         }
     }
-    /**
-     * Get a connection
-     * @return {ConnectionTransaction} object - Connection for the transaction
-     * @type     {object} connection
-     * @property {function} connection.query - execute query sql then release connection to pool
-     * @property {function} connection.startTransaction - start transaction of query
-     * @property {function} connection.commit - commit transaction of query
-     * @property {function} connection.rollback - rollback transaction of query
-     */
-    beginTransaction() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const pool = yield this.$pool.get();
-            return yield pool.connection();
-        });
-    }
     /**
      * Assign table name
      * @static
@@ -329,13 +335,20 @@ class DB extends AbstractDB_1.AbstractDB {
      * @return {Connection}
      */
     static getConnection(options) {
-        const { host, port, database, username: user, password } = options, others = __rest(options, ["host", "port", "database", "username", "password"]);
-        const pool = new connection_1.PoolConnection(Object.assign({ host,
-            port,
-            database,
-            user,
-            password }, others));
-        return pool.connection();
+        return __awaiter(this, void 0, void 0, function* () {
+            if (options == null) {
+                const self = new this();
+                const pool = yield self.$pool.get();
+                return yield pool.connection();
+            }
+            const { host, port, database, username: user, password } = options, others = __rest(options, ["host", "port", "database", "username", "password"]);
+            const pool = new connection_1.PoolConnection(Object.assign({ host,
+                port,
+                database,
+                user,
+                password }, others));
+            return pool.connection();
+        });
     }
     _typeOf(data) {
         return Object.prototype.toString.apply(data).slice(8, -1).toLocaleLowerCase();

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

@@ -55,6 +55,18 @@ export interface Backup {
 export interface BackupToFile {
     database: string;
     filePath: string;
+    table?: string;
+    connection?: {
+        host: string;
+        port: number;
+        database: string;
+        username: string;
+        password: string;
+    };
+}
+export interface BackupTableToFile {
+    filePath: string;
+    table: string;
     connection?: {
         host: string;
         port: number;

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.4.0",
   "description": "mysql query builder object relational mapping",
   "main": "dist/lib/index.js",
   "types": "dist/lib/index.d.ts",