tspace-mysql 1.8.2 → 1.8.3

package/build/lib/core/DB.d.ts

@@ -1,5 +1,5 @@
-import { AbstractDB } from './Abstracts/AbstractDB';
-import type { TConstant, TBackup, TBackupTableToFile, TBackupToFile, TConnection, TConnectionOptions, TConnectionTransaction, TRawStringQuery, TFreezeStringQuery } from '../types';
+import { AbstractDB } from "./Abstracts/AbstractDB";
+import type { TConstant, TBackup, TBackupTableToFile, TBackupToFile, TConnection, TConnectionOptions, TConnectionTransaction, TRawStringQuery, TFreezeStringQuery } from "../types";
 /**
  * 'DB' Class is a component of the database system
  * @param {string?} table table name
@@ -206,15 +206,15 @@ declare class DB extends AbstractDB {
      */
     getConnection(options?: TConnectionOptions): Promise<TConnection>;
     /**
-   * The 'getConnection' method is used to get a pool connection.
-   * @param {Object} options options for connection database with credentials
-   * @property {string} option.host
-   * @property {number} option.port
-   * @property {string} option.database
-   * @property {string} option.username
-   * @property {string} option.password
-   * @returns {Connection}
-   */
+     * The 'getConnection' method is used to get a pool connection.
+     * @param {Object} options options for connection database with credentials
+     * @property {string} option.host
+     * @property {number} option.port
+     * @property {string} option.database
+     * @property {string} option.username
+     * @property {string} option.password
+     * @returns {Connection}
+     */
     static getConnection(options: TConnectionOptions): Promise<TConnection>;
     /**
      * The 'beginTransaction' is a method used to initiate a database transaction within your application's code.
@@ -271,11 +271,11 @@ declare class DB extends AbstractDB {
      */
     cloneDB(database: string): Promise<void>;
     /**
-    *
-    * This 'cloneDB' method is used to clone current database to new database
-    * @param {string} database clone current database to new database name
-    * @returns {Promise<boolean>}
-    */
+     *
+     * This 'cloneDB' method is used to clone current database to new database
+     * @param {string} database clone current database to new database name
+     * @returns {Promise<boolean>}
+     */
     static cloneDB(database: string): Promise<void>;
     /**
      *
@@ -317,22 +317,22 @@ declare class DB extends AbstractDB {
      * @property {string} backup.connection.password
      * @returns {Promise<void>}
      */
-    backupToFile({ filePath, database, connection }: TBackupToFile): Promise<void>;
-    /**
-    *
-    * This 'backupToFile' method is used to backup database intro new ${file}.sql
-    * @type {Object}  backup
-    * @property {string} backup.database
-    * @property {string} backup.filePath
-    * @type     {object?} backup.connection
-    * @property {string} backup.connection.host
-    * @property {number} backup.connection.port
-    * @property {number} backup.connection.database
-    * @property {string} backup.connection.username
-    * @property {string} backup.connection.password
-    * @returns {Promise<void>}
-    */
-    static backupToFile({ filePath, database, connection }: TBackupToFile): Promise<void>;
+    backupToFile({ filePath, database, connection, }: TBackupToFile): Promise<void>;
+    /**
+     *
+     * This 'backupToFile' method is used to backup database intro new ${file}.sql
+     * @type {Object}  backup
+     * @property {string} backup.database
+     * @property {string} backup.filePath
+     * @type     {object?} backup.connection
+     * @property {string} backup.connection.host
+     * @property {number} backup.connection.port
+     * @property {number} backup.connection.database
+     * @property {string} backup.connection.username
+     * @property {string} backup.connection.password
+     * @returns {Promise<void>}
+     */
+    static backupToFile({ filePath, database, connection, }: TBackupToFile): Promise<void>;
     /**
      *
      * This 'backupSchemaToFile' method is used to backup database intro new ${file}.sql
@@ -347,7 +347,7 @@ declare class DB extends AbstractDB {
      * @property {string} backup.connection.password
      * @returns {Promise<void>}
      */
-    backupSchemaToFile({ filePath, database, connection }: TBackupToFile): Promise<void>;
+    backupSchemaToFile({ filePath, database, connection, }: TBackupToFile): Promise<void>;
     /**
      *
      * This 'backupSchemaToFile' method is used to backup database intro new ${file}.sql
@@ -363,7 +363,7 @@ declare class DB extends AbstractDB {
      * @property {string} backup.connection.password
      * @returns {Promise<void>}
      */
-    static backupSchemaToFile({ filePath, database, connection }: TBackupToFile): Promise<void>;
+    static backupSchemaToFile({ filePath, database, connection, }: TBackupToFile): Promise<void>;
     /**
      *
      * This 'backupTableToFile' method is used to backup database intro new ${file}.sql
@@ -379,7 +379,7 @@ declare class DB extends AbstractDB {
      * @property {string} backup.connection.password
      * @returns {Promise<void>}
      */
-    backupTableToFile({ filePath, table, connection }: TBackupTableToFile): Promise<void>;
+    backupTableToFile({ filePath, table, connection, }: TBackupTableToFile): Promise<void>;
     /**
      *
      * This 'backupTableSchemaToFile' method is used to backup database intro new ${file}.sql
@@ -394,7 +394,7 @@ declare class DB extends AbstractDB {
      * @property {string} backup.connection.password
      * @returns {Promise<void>}
      */
-    static backupTableToFile({ filePath, table, connection }: TBackupTableToFile): Promise<void>;
+    static backupTableToFile({ filePath, table, connection, }: TBackupTableToFile): Promise<void>;
     /**
      *
      * This 'backupTableSchemaToFile' method is used to backup database intro new ${file}.sql
@@ -409,7 +409,7 @@ declare class DB extends AbstractDB {
      * @property {string} backup.connection.password
      * @returns {Promise<void>}
      */
-    backupTableSchemaToFile({ filePath, table, connection }: TBackupTableToFile): Promise<void>;
+    backupTableSchemaToFile({ filePath, table, connection, }: TBackupTableToFile): Promise<void>;
     /**
      *
      * This 'backupTableSchemaToFile' method is used to backup database intro new ${file}.sql
@@ -424,7 +424,7 @@ declare class DB extends AbstractDB {
      * @property {string} backup.connection.password
      * @returns {Promise<void>}
      */
-    static backupTableSchemaToFile({ filePath, table, connection }: TBackupTableToFile): Promise<void>;
+    static backupTableSchemaToFile({ filePath, table, connection, }: TBackupTableToFile): Promise<void>;
     private _backup;
     private _initialDB;
 }

package/build/lib/core/DB.js

@@ -24,7 +24,7 @@ exports.DB = void 0;
 const sql_formatter_1 = require("sql-formatter");
 const AbstractDB_1 = require("./Abstracts/AbstractDB");
 const Proxy_1 = require("./Handlers/Proxy");
-const connection_1 = require("../connection");
+const Pool_1 = require("./Pool");
 const State_1 = require("./Handlers/State");
 const tools_1 = require("../tools");
 /**
@@ -64,7 +64,7 @@ class DB extends AbstractDB_1.AbstractDB {
                 for (const key in parameters) {
                     const parameter = parameters[key];
                     if (parameter === null) {
-                        bindSql = bindSql.replace(`:${key}`, this.$constants('NULL'));
+                        bindSql = bindSql.replace(`:${key}`, this.$constants("NULL"));
                         continue;
                     }
                     if (parameter === true || parameter === false) {
@@ -72,7 +72,7 @@ class DB extends AbstractDB_1.AbstractDB {
                         continue;
                     }
                     bindSql = bindSql.replace(`:${key}`, Array.isArray(parameter)
-                        ? `(${parameter.map(p => `'${this.escape(p)}'`).join(',')})`
+                        ? `(${parameter.map((p) => `'${this.escape(p)}'`).join(",")})`
                         : `'${this.escape(parameter)}'`);
                 }
                 return yield this.rawQuery(bindSql);
@@ -130,13 +130,17 @@ class DB extends AbstractDB_1.AbstractDB {
         let maping = [];
         for (const [key, value] of Object.entries(object)) {
             if (/\./.test(value)) {
-                const [table, c] = value.split('.');
+                const [table, c] = value.split(".");
                 maping = [...maping, `'${key}'`, `\`${table}\`.\`${c}\``];
                 continue;
             }
-            maping = [...maping, `'${key}'`, `\`${this.getTableName()}\`.\`${value}\``];
+            maping = [
+                ...maping,
+                `'${key}'`,
+                `\`${this.getTableName()}\`.\`${value}\``,
+            ];
         }
-        return `${this.$constants('JSON_OBJECT')}(${maping.join(' , ')}) ${this.$constants('AS')} \`${alias}\``;
+        return `${this.$constants("JSON_OBJECT")}(${maping.join(" , ")}) ${this.$constants("AS")} \`${alias}\``;
     }
     /**
      * The 'jsonObject' method is used to specify select data to JSON objects.
@@ -201,16 +205,16 @@ class DB extends AbstractDB_1.AbstractDB {
                 throw new Error(`can't find then condition`);
             query = [
                 ...query,
-                `${this.$constants('WHEN')} ${c.when} ${this.$constants('THEN')} ${c.then}`
+                `${this.$constants("WHEN")} ${c.when} ${this.$constants("THEN")} ${c.then}`,
             ];
         }
         return [
-            this.$constants('RAW'),
-            this.$constants('CASE'),
-            query.join(' '),
-            final == null ? '' : `ELSE ${final}`,
-            this.$constants('END')
-        ].join(' ');
+            this.$constants("RAW"),
+            this.$constants("CASE"),
+            query.join(" "),
+            final == null ? "" : `ELSE ${final}`,
+            this.$constants("END"),
+        ].join(" ");
     }
     /**
      * select by cases
@@ -299,7 +303,7 @@ class DB extends AbstractDB_1.AbstractDB {
      * @returns {string} string
      */
     raw(sql) {
-        return `${this.$constants('RAW')}${sql}`;
+        return `${this.$constants("RAW")}${sql}`;
     }
     /**
      * The 'raw' methid is used to allow for raw sql queries to some method in 'DB' or 'Model'.
@@ -317,7 +321,7 @@ class DB extends AbstractDB_1.AbstractDB {
      * @returns {string} string
      */
     freeze(column) {
-        return `${this.$constants('FREEZE')}${column}`;
+        return `${this.$constants("FREEZE")}${column}`;
     }
     /**
      * The 'freeze' methid is used to freeze the column without any pattern.
@@ -343,27 +347,27 @@ class DB extends AbstractDB_1.AbstractDB {
         return __awaiter(this, void 0, void 0, function* () {
             if (options == null) {
                 const pool = yield this.$pool.get();
-                return yield pool.connection();
+                return yield pool.newConnection();
             }
             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,
+            const pool = new Pool_1.PoolConnection(Object.assign({ host,
                 port,
                 database,
                 user,
                 password }, others));
-            return pool.connected();
+            return pool.newConnected();
         });
     }
     /**
-   * The 'getConnection' method is used to get a pool connection.
-   * @param {Object} options options for connection database with credentials
-   * @property {string} option.host
-   * @property {number} option.port
-   * @property {string} option.database
-   * @property {string} option.username
-   * @property {string} option.password
-   * @returns {Connection}
-   */
+     * The 'getConnection' method is used to get a pool connection.
+     * @param {Object} options options for connection database with credentials
+     * @property {string} option.host
+     * @property {number} option.port
+     * @property {string} option.database
+     * @property {string} option.username
+     * @property {string} option.password
+     * @returns {Connection}
+     */
     static getConnection(options) {
         return __awaiter(this, void 0, void 0, function* () {
             return new this().getConnection(options);
@@ -385,7 +389,7 @@ class DB extends AbstractDB_1.AbstractDB {
      */
     beginTransaction() {
         return __awaiter(this, void 0, void 0, function* () {
-            const pool = new connection_1.PoolConnection().connected();
+            const pool = new Pool_1.PoolConnection().newConnected();
             return yield pool.connection();
         });
     }
@@ -418,7 +422,7 @@ class DB extends AbstractDB_1.AbstractDB {
      */
     removeProperties(data, propertiesToRemoves) {
         const setNestedProperty = (obj, path, value) => {
-            const segments = path.split('.');
+            const segments = path.split(".");
             let currentObj = obj;
             for (let i = 0; i < segments.length - 1; i++) {
                 const segment = segments[i];
@@ -435,16 +439,16 @@ class DB extends AbstractDB_1.AbstractDB {
             for (const property of propertiesToRemoves) {
                 if (property == null)
                     continue;
-                const properties = property.split('.');
+                const properties = property.split(".");
                 let current = temp;
-                let afterProp = '';
+                let afterProp = "";
                 const props = [];
                 for (let i = 0; i < properties.length - 1; i++) {
                     const prop = properties[i];
                     if (current[prop] == null)
                         continue;
                     props.push(prop);
-                    if (typeof current[prop] === 'object' && current[prop] != null) {
+                    if (typeof current[prop] === "object" && current[prop] != null) {
                         current = current[prop];
                         afterProp = prop;
                         continue;
@@ -454,7 +458,7 @@ class DB extends AbstractDB_1.AbstractDB {
                 }
                 const lastProp = properties[properties.length - 1];
                 if (Array.isArray(current)) {
-                    setNestedProperty(temp, props.join('.'), this.removeProperties(current, [afterProp, lastProp]));
+                    setNestedProperty(temp, props.join("."), this.removeProperties(current, [afterProp, lastProp]));
                     continue;
                 }
                 if (current[lastProp] == null)
@@ -464,7 +468,7 @@ class DB extends AbstractDB_1.AbstractDB {
             return temp;
         };
         if (Array.isArray(data)) {
-            return data.map(obj => remove(obj, propertiesToRemoves));
+            return data.map((obj) => remove(obj, propertiesToRemoves));
         }
         return remove(data, propertiesToRemoves);
     }
@@ -487,30 +491,30 @@ class DB extends AbstractDB_1.AbstractDB {
     cloneDB(database) {
         return __awaiter(this, void 0, void 0, function* () {
             var _a;
-            const db = yield this._queryStatement(`${this.$constants('SHOW_DATABASES')} ${this.$constants('LIKE')} '${database}'`);
+            const db = yield this._queryStatement(`${this.$constants("SHOW_DATABASES")} ${this.$constants("LIKE")} '${database}'`);
             if (Object.values((_a = db[0]) !== null && _a !== void 0 ? _a : []).length)
                 throw new Error(`This database : '${database}' is already exists`);
             const tables = yield this.showTables();
             const backup = yield this._backup({ tables, database });
-            yield this._queryStatement(`${this.$constants('CREATE_DATABASE_NOT_EXISTS')} \`${database}\``);
-            const creating = (_b) => __awaiter(this, [_b], void 0, function* ({ table, values }) {
+            yield this._queryStatement(`${this.$constants("CREATE_DATABASE_NOT_EXISTS")} \`${database}\``);
+            const creating = (_b) => __awaiter(this, [_b], void 0, function* ({ table, values, }) {
                 try {
                     yield this._queryStatement(table);
-                    if (values != null && values !== '')
+                    if (values != null && values !== "")
                         yield this._queryStatement(values);
                 }
                 catch (e) { }
             });
-            yield Promise.all(backup.map(b => creating({ table: b.table, values: b.values })));
+            yield Promise.all(backup.map((b) => creating({ table: b.table, values: b.values })));
             return;
         });
     }
     /**
-    *
-    * This 'cloneDB' method is used to clone current database to new database
-    * @param {string} database clone current database to new database name
-    * @returns {Promise<boolean>}
-    */
+     *
+     * This 'cloneDB' method is used to clone current database to new database
+     * @param {string} database clone current database to new database name
+     * @returns {Promise<boolean>}
+     */
     static cloneDB(database) {
         return __awaiter(this, void 0, void 0, function* () {
             return new this().cloneDB(database);
@@ -567,29 +571,30 @@ class DB extends AbstractDB_1.AbstractDB {
      * @returns {Promise<void>}
      */
     backupToFile(_a) {
-        return __awaiter(this, arguments, void 0, function* ({ filePath, database = `dump_${+new Date()}`, connection }) {
+        return __awaiter(this, arguments, void 0, function* ({ filePath, database = `dump_${+new Date()}`, connection, }) {
             var _b;
             yield this.$utils.wait(1000 * 3);
             const tables = yield this.showTables();
-            const backup = (yield this._backup({ tables, database }))
-                .map(b => {
+            const backup = (yield this._backup({ tables, database })).map((b) => {
                 return {
                     table: [
                         `\n--`,
                         `-- Table structure for table '${b.name}'`,
                         `--\n`,
                         `${(0, sql_formatter_1.format)(b.table, {
-                            language: 'spark',
+                            language: "spark",
                             tabWidth: 2,
-                            linesBetweenQueries: 1
-                        })}`
-                    ].join('\n'),
-                    values: b.values !== '' ? [
-                        `\n--`,
-                        `-- Dumping data for table '${b.name}'`,
-                        `--\n`,
-                        `${b.values}`
-                    ].join('\n') : ''
+                            linesBetweenQueries: 1,
+                        })}`,
+                    ].join("\n"),
+                    values: b.values !== ""
+                        ? [
+                            `\n--`,
+                            `-- Dumping data for table '${b.name}'`,
+                            `--\n`,
+                            `${b.values}`,
+                        ].join("\n")
+                        : "",
                 };
             });
             if (connection != null && ((_b = Object.keys(connection)) === null || _b === void 0 ? void 0 : _b.length))
@@ -606,9 +611,9 @@ class DB extends AbstractDB_1.AbstractDB {
                 `--`,
                 `-- Database: '${database}'`,
                 `--\n`,
-                `${this.$constants('CREATE_DATABASE_NOT_EXISTS')} \`${database}\`;`,
+                `${this.$constants("CREATE_DATABASE_NOT_EXISTS")} \`${database}\`;`,
                 `USE \`${database}\`;`,
-                `-- --------------------------------------------------------`
+                `-- --------------------------------------------------------`,
             ];
             for (const b of backup) {
                 sql = [...sql, b.table];
@@ -616,26 +621,26 @@ class DB extends AbstractDB_1.AbstractDB {
                     sql = [...sql, b.values];
                 }
             }
-            tools_1.Tool.fs.writeFileSync(filePath, [...sql, 'COMMIT;'].join('\n'));
+            tools_1.Tool.fs.writeFileSync(filePath, [...sql, "COMMIT;"].join("\n"));
             return;
         });
     }
     /**
-    *
-    * This 'backupToFile' method is used to backup database intro new ${file}.sql
-    * @type {Object}  backup
-    * @property {string} backup.database
-    * @property {string} backup.filePath
-    * @type     {object?} backup.connection
-    * @property {string} backup.connection.host
-    * @property {number} backup.connection.port
-    * @property {number} backup.connection.database
-    * @property {string} backup.connection.username
-    * @property {string} backup.connection.password
-    * @returns {Promise<void>}
-    */
+     *
+     * This 'backupToFile' method is used to backup database intro new ${file}.sql
+     * @type {Object}  backup
+     * @property {string} backup.database
+     * @property {string} backup.filePath
+     * @type     {object?} backup.connection
+     * @property {string} backup.connection.host
+     * @property {number} backup.connection.port
+     * @property {number} backup.connection.database
+     * @property {string} backup.connection.username
+     * @property {string} backup.connection.password
+     * @returns {Promise<void>}
+     */
     static backupToFile(_a) {
-        return __awaiter(this, arguments, void 0, function* ({ filePath, database, connection }) {
+        return __awaiter(this, arguments, void 0, function* ({ filePath, database, connection, }) {
             return new this().backupToFile({ filePath, database, connection });
         });
     }
@@ -654,32 +659,31 @@ class DB extends AbstractDB_1.AbstractDB {
      * @returns {Promise<void>}
      */
     backupSchemaToFile(_a) {
-        return __awaiter(this, arguments, void 0, function* ({ filePath, database = `dump_${+new Date()}`, connection }) {
+        return __awaiter(this, arguments, void 0, function* ({ filePath, database = `dump_${+new Date()}`, connection, }) {
             var _b;
             if (connection != null && ((_b = Object.keys(connection)) === null || _b === void 0 ? void 0 : _b.length))
                 this.connection(connection);
             yield this.$utils.wait(1000 * 3);
             const tables = yield this.showTables();
-            const backup = (yield this._backup({ tables, database }))
-                .map(b => {
+            const backup = (yield this._backup({ tables, database })).map((b) => {
                 return {
                     table: (0, sql_formatter_1.format)(b.table, {
-                        language: 'spark',
+                        language: "spark",
                         tabWidth: 2,
                         linesBetweenQueries: 1,
-                    }) + "\n"
+                    }) + "\n",
                 };
             });
             let sql = [
                 `SET SQL_MODE = "NO_AUTO_VALUE_ON_ZERO";`,
                 `START TRANSACTION;`,
                 `SET time_zone = "+00:00";`,
-                `${this.$constants('CREATE_DATABASE_NOT_EXISTS')} \`${database}\`;`,
-                `USE \`${database}\`;`
+                `${this.$constants("CREATE_DATABASE_NOT_EXISTS")} \`${database}\`;`,
+                `USE \`${database}\`;`,
             ];
             for (const b of backup)
                 sql = [...sql, b.table];
-            tools_1.Tool.fs.writeFileSync(filePath, [...sql, 'COMMIT;'].join('\n'));
+            tools_1.Tool.fs.writeFileSync(filePath, [...sql, "COMMIT;"].join("\n"));
             return;
         });
     }
@@ -699,7 +703,7 @@ class DB extends AbstractDB_1.AbstractDB {
      * @returns {Promise<void>}
      */
     static backupSchemaToFile(_a) {
-        return __awaiter(this, arguments, void 0, function* ({ filePath, database, connection }) {
+        return __awaiter(this, arguments, void 0, function* ({ filePath, database, connection, }) {
             return new this().backupSchemaToFile({ filePath, database, connection });
         });
     }
@@ -719,7 +723,7 @@ class DB extends AbstractDB_1.AbstractDB {
      * @returns {Promise<void>}
      */
     backupTableToFile(_a) {
-        return __awaiter(this, arguments, void 0, function* ({ filePath, table, connection }) {
+        return __awaiter(this, arguments, void 0, function* ({ filePath, table, connection, }) {
             var _b;
             if (connection != null && ((_b = Object.keys(connection)) === null || _b === void 0 ? void 0 : _b.length))
                 this.connection(connection);
@@ -730,31 +734,31 @@ class DB extends AbstractDB_1.AbstractDB {
             yield this.$utils.wait(1000 * 5);
             const schemas = yield this.showSchema(table);
             const createTableSQL = [
-                `${this.$constants('CREATE_TABLE_NOT_EXISTS')}`,
+                `${this.$constants("CREATE_TABLE_NOT_EXISTS")}`,
                 `\`${table}\``,
-                `(${schemas.join(',')})`,
-                `${this.$constants('ENGINE')};`,
+                `(${schemas.join(",")})`,
+                `${this.$constants("ENGINE")};`,
             ];
             const values = yield this.showValues(table);
             let valueSQL = [];
             if (values.length) {
                 const columns = yield this.showColumns(table);
                 valueSQL = [
-                    `${this.$constants('INSERT')}`,
+                    `${this.$constants("INSERT")}`,
                     `\`${table}\``,
-                    `(${columns.map((column) => `\`${column}\``).join(',')})`,
-                    `${this.$constants('VALUES')} ${values.join(',')};`
+                    `(${columns.map((column) => `\`${column}\``).join(",")})`,
+                    `${this.$constants("VALUES")} ${values.join(",")};`,
                 ];
             }
             const sql = [
-                (0, sql_formatter_1.format)(createTableSQL.join(' '), {
-                    language: 'mysql',
+                (0, sql_formatter_1.format)(createTableSQL.join(" "), {
+                    language: "mysql",
                     tabWidth: 2,
                     linesBetweenQueries: 1,
                 }) + "\n",
-                valueSQL.join(' ')
+                valueSQL.join(" "),
             ];
-            tools_1.Tool.fs.writeFileSync(filePath, [...sql, 'COMMIT;'].join('\n'));
+            tools_1.Tool.fs.writeFileSync(filePath, [...sql, "COMMIT;"].join("\n"));
             return;
         });
     }
@@ -773,7 +777,7 @@ class DB extends AbstractDB_1.AbstractDB {
      * @returns {Promise<void>}
      */
     static backupTableToFile(_a) {
-        return __awaiter(this, arguments, void 0, function* ({ filePath, table, connection }) {
+        return __awaiter(this, arguments, void 0, function* ({ filePath, table, connection, }) {
             return new this().backupTableToFile({ filePath, table, connection });
         });
     }
@@ -792,21 +796,21 @@ class DB extends AbstractDB_1.AbstractDB {
      * @returns {Promise<void>}
      */
     backupTableSchemaToFile(_a) {
-        return __awaiter(this, arguments, void 0, function* ({ filePath, table, connection }) {
+        return __awaiter(this, arguments, void 0, function* ({ filePath, table, connection, }) {
             var _b;
             const schemas = yield this.showSchema(table);
             const createTableSQL = [
-                `${this.$constants('CREATE_TABLE_NOT_EXISTS')}`,
+                `${this.$constants("CREATE_TABLE_NOT_EXISTS")}`,
                 `\`${table}\``,
-                `(${schemas.join(',')})`,
-                `${this.$constants('ENGINE')};`,
+                `(${schemas.join(",")})`,
+                `${this.$constants("ENGINE")};`,
             ];
-            const sql = [createTableSQL.join(' ')];
+            const sql = [createTableSQL.join(" ")];
             if (connection != null && ((_b = Object.keys(connection)) === null || _b === void 0 ? void 0 : _b.length))
                 this.connection(connection);
             yield this.$utils.wait(1000 * 5);
-            tools_1.Tool.fs.writeFileSync(filePath, (0, sql_formatter_1.format)(sql.join('\n'), {
-                language: 'spark',
+            tools_1.Tool.fs.writeFileSync(filePath, (0, sql_formatter_1.format)(sql.join("\n"), {
+                language: "spark",
                 tabWidth: 2,
                 linesBetweenQueries: 1,
             }));
@@ -828,44 +832,44 @@ class DB extends AbstractDB_1.AbstractDB {
      * @returns {Promise<void>}
      */
     static backupTableSchemaToFile(_a) {
-        return __awaiter(this, arguments, void 0, function* ({ filePath, table, connection }) {
+        return __awaiter(this, arguments, void 0, function* ({ filePath, table, connection, }) {
             return new this().backupTableSchemaToFile({ filePath, table, connection });
         });
     }
     _backup(_a) {
-        return __awaiter(this, arguments, void 0, function* ({ tables, database }) {
+        return __awaiter(this, arguments, void 0, function* ({ tables, database, }) {
             const backup = [];
             for (const table of tables) {
                 const schemas = yield this.showSchema(table);
                 const createTableSQL = [
-                    `${this.$constants('CREATE_TABLE_NOT_EXISTS')}`,
+                    `${this.$constants("CREATE_TABLE_NOT_EXISTS")}`,
                     `\`${database}\`.\`${table}\``,
-                    `(${schemas.join(', ')})`,
-                    `${this.$constants('ENGINE')};`,
+                    `(${schemas.join(", ")})`,
+                    `${this.$constants("ENGINE")};`,
                 ];
                 const values = yield this.showValues(table);
                 let valueSQL = [];
                 if (values.length) {
                     const columns = yield this.showColumns(table);
                     valueSQL = [
-                        `${this.$constants('INSERT')}`,
+                        `${this.$constants("INSERT")}`,
                         `\`${database}\`.\`${table}\``,
-                        `(${columns.map((column) => `\`${column}\``).join(', ')})`,
-                        `${this.$constants('VALUES')}`,
-                        `\n${values.join(',\n')};`
+                        `(${columns.map((column) => `\`${column}\``).join(", ")})`,
+                        `${this.$constants("VALUES")}`,
+                        `\n${values.join(",\n")};`,
                     ];
                 }
                 backup.push({
-                    name: table == null ? '' : table,
-                    table: createTableSQL.join(' '),
-                    values: valueSQL.join(' '),
+                    name: table == null ? "" : table,
+                    table: createTableSQL.join(" "),
+                    values: valueSQL.join(" "),
                 });
             }
             return backup;
         });
     }
     _initialDB() {
-        this.$state = new State_1.StateHandler('db');
+        this.$state = new State_1.StateHandler("db");
         return this;
     }
 }