tspace-mysql 1.2.9 → 1.3.1

package/dist/cli/models/model.js

@@ -1,6 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const Model = (model, npm) => {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const Model = (model, npm) => {
     return `import { Model } from '${npm}'
 class ${model} extends Model {
   constructor(){
@@ -10,21 +10,30 @@ class ${model} extends Model {
      * Assign setting global in your model
      * @useMethod
      *
-     * this.useDebug() // => runing a uuid (universally unique identifier) when insert new data
-     * this.usePrimaryKey('id') // => runing a uuid (universally unique identifier) when insert new data
-     * this.useTimestamp({ createdAt : 'created_at' , updatedAt : 'updated_at' }) // runing a timestamp when insert or update
+     * this.useDebug() 
+     * 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.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
     */
   }
 }
 export { ${model} }
 export default ${model}
-`;
-};
-exports.default = Model;
+`;
+};
+exports.default = Model;

package/dist/cli/query/index.d.ts

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

package/dist/cli/query/index.js

@@ -1,7 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const lib_1 = require("../../lib");
-exports.default = (cmd) => {
-    const { sql } = cmd;
-    new lib_1.DB().rawQuery(sql === null || sql === void 0 ? void 0 : sql.replace(/`/g, '')).then(result => console.log(result));
-};
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const lib_1 = require("../../lib");
+exports.default = (cmd) => {
+    const { sql } = cmd;
+    new lib_1.DB().rawQuery(sql === null || sql === void 0 ? void 0 : sql.replace(/`/g, '')).then(result => console.log(result));
+};

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

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

package/dist/cli/tables/make.js

@@ -1,26 +1,26 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const table_1 = __importDefault(require("./table"));
-exports.default = (formCommand) => {
-    const { file, type, cwd, dir, fs, npm } = formCommand;
-    try {
-        fs.accessSync(cwd + `/${file}`, fs.F_OK, {
-            recursive: true
-        });
-    }
-    catch (e) {
-        fs.mkdirSync(cwd + `/${file}`, {
-            recursive: true
-        });
-    }
-    const folderMigrate = dir ? `${cwd}/${dir}/create_${file}_table${type}` : `${cwd}/create_${file}_table${type}`;
-    const table = (0, table_1.default)(file, npm);
-    fs.writeFile(folderMigrate, table, (err) => {
-        if (err)
-            console.log(err.message);
-    });
-    console.log(`Migration : ${file} created successfully`);
-};
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const table_1 = __importDefault(require("./table"));
+exports.default = (formCommand) => {
+    const { file, type, cwd, dir, fs, npm } = formCommand;
+    try {
+        fs.accessSync(cwd + `/${file}`, fs.F_OK, {
+            recursive: true
+        });
+    }
+    catch (e) {
+        fs.mkdirSync(cwd + `/${file}`, {
+            recursive: true
+        });
+    }
+    const folderMigrate = dir ? `${cwd}/${dir}/create_${file}_table${type}` : `${cwd}/create_${file}_table${type}`;
+    const table = (0, table_1.default)(file, npm);
+    fs.writeFile(folderMigrate, table, (err) => {
+        if (err)
+            console.log(err.message);
+    });
+    console.log(`Migration : ${file} created successfully`);
+};

package/dist/cli/tables/table.d.ts

@@ -1,2 +1,2 @@
-declare const Table: (table: string, npm: string) => string;
-export default Table;
+declare const Table: (table: string, npm: string) => string;
+export default Table;

package/dist/cli/tables/table.js

@@ -1,6 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const Table = (table, npm) => {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const Table = (table, npm) => {
     return `import { Schema , Blueprint , DB } from '${npm}'
 (async () => {
     await new Schema().table('${table}',{ 
@@ -21,6 +21,6 @@ const Table = (table, npm) => {
      *  await new DB().table('${table}').faker(5)
     */
 })()
-`;
-};
-exports.default = Table;
+`;
+};
+exports.default = Table;

package/dist/lib/connection/index.d.ts

@@ -1,30 +1,30 @@
-import { Connection, Options } from '../tspace/Interface';
-export declare class PoolConnection {
-    private OPTIONS;
-    /**
-     *
-     * @Init a options connection pool
-     */
-    constructor(options?: Options);
-    /**
-     *
-     * Get a connection to database
-     * @return {Connection} Connection
-     * @property {Function} Connection.query
-     * @property {Function} Connection.connection
-     */
-    connection(): Connection;
-    private _defaultOptions;
-    private _loadOptions;
-    private _messageError;
-}
-/**
- *
- * Connection to database when service is started
- * @return {Connection} Connection
- * @property {Function} Connection.query
- * @property {Function} Connection.connection
- */
-declare const pool: Connection;
-export { pool as Pool };
-export default pool;
+import { Connection, Options } from '../tspace/Interface';
+export declare class PoolConnection {
+    private OPTIONS;
+    /**
+     *
+     * @Init a options connection pool
+     */
+    constructor(options?: Options);
+    /**
+     *
+     * Get a connection to database
+     * @return {Connection} Connection
+     * @property {Function} Connection.query
+     * @property {Function} Connection.connection
+     */
+    connection(): Connection;
+    private _defaultOptions;
+    private _loadOptions;
+    private _messageError;
+}
+/**
+ *
+ * Connection to database when service is started
+ * @return {Connection} Connection
+ * @property {Function} Connection.query
+ * @property {Function} Connection.connection
+ */
+declare const pool: Connection;
+export { pool as Pool };
+export default pool;

package/dist/lib/connection/index.js

@@ -1,132 +1,133 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Pool = exports.PoolConnection = void 0;
-const fs_1 = __importDefault(require("fs"));
-const path_1 = __importDefault(require("path"));
-const options_1 = __importDefault(require("./options"));
-const mysql2_1 = require("mysql2");
-class PoolConnection {
-    /**
-     *
-     * @Init a options connection pool
-     */
-    constructor(options) {
-        this.OPTIONS = this._loadOptions();
-        if (options) {
-            this.OPTIONS = new Map(Object.entries(Object.assign(Object.assign({}, Object.fromEntries(this.OPTIONS)), JSON.parse(JSON.stringify(options)))));
-        }
-    }
-    /**
-     *
-     * Get a connection to database
-     * @return {Connection} Connection
-     * @property {Function} Connection.query
-     * @property {Function} Connection.connection
-     */
-    connection() {
-        const pool = (0, mysql2_1.createPool)(Object.fromEntries(this.OPTIONS));
-        if (options_1.default.CONNECTION_ERROR) {
-            pool.getConnection((err, _) => {
-                if (err == null || !err)
-                    return;
-                const message = this._messageError.bind(this);
-                process.nextTick(() => {
-                    console.log(message());
-                    return process.exit();
-                });
-            });
-        }
-        return {
-            query: (sql) => {
-                return new Promise((resolve, reject) => {
-                    pool.query(sql, (err, results) => {
-                        if (err)
-                            return reject(err);
-                        return resolve(results);
-                    });
-                });
-            },
-            connection: () => {
-                return new Promise((resolve, reject) => {
-                    pool.getConnection((err, connection) => {
-                        if (err)
-                            return reject(err);
-                        const query = (sql) => {
-                            return new Promise((resolve, reject) => {
-                                connection.query(sql, (err, result) => {
-                                    if (err)
-                                        return reject(err);
-                                    return resolve(result);
-                                });
-                            });
-                        };
-                        const startTransaction = () => query('START TRANSACTION');
-                        const commit = () => query('COMMIT');
-                        const rollback = () => query('ROLLBACK');
-                        return resolve({
-                            query,
-                            startTransaction,
-                            commit,
-                            rollback
-                        });
-                    });
-                });
-            }
-        };
-    }
-    _defaultOptions() {
-        return new Map(Object.entries({
-            connectionLimit: Number(options_1.default.CONNECTION_LIMIT),
-            dateStrings: Boolean(options_1.default.DATE_STRINGS),
-            connectTimeout: Number(options_1.default.TIMEOUT),
-            waitForConnections: Boolean(options_1.default.WAIT_FOR_CONNECTIONS),
-            queueLimit: Number(options_1.default.QUEUE_LIMIT),
-            charset: String(options_1.default.CHARSET),
-            host: String(options_1.default.HOST),
-            port: Number.isNaN(Number(options_1.default.PORT))
-                ? 3306
-                : Number(options_1.default.PORT),
-            database: String(options_1.default.DATABASE),
-            user: String(options_1.default.USERNAME),
-            password: String(options_1.default.PASSWORD) !== ''
-                ? String(options_1.default.PASSWORD)
-                : ''
-        }));
-    }
-    _loadOptions() {
-        try {
-            /**
-             *
-             * @Json connection
-             *
-                "host"                  : "",
-                "port"                  : "",
-                "database"              : "",
-                "user"                  : "",
-                "password"              : "",
-                "connectionLimit"       : "",
-                "dateStrings"           : "",
-                "idleTimeout"           : "",
-                "waitForConnections"    : "",
-                "queueLimit"            : "",
-                "charset"               : ""
-             */
-            const jsonPath = path_1.default.join(path_1.default.resolve(), 'tspace-mysql.json');
-            const jsonOptionsExists = fs_1.default.existsSync(jsonPath);
-            if (!jsonOptionsExists)
-                return this._defaultOptions();
-            const jsonOptions = fs_1.default.readFileSync(jsonPath, 'utf8');
-            const options = JSON.parse(jsonOptions);
-            return new Map(Object.entries(options));
-        }
-        catch (e) {
-            return this._defaultOptions();
-        }
-    }
-    _messageError() {
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Pool = exports.PoolConnection = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const options_1 = __importDefault(require("./options"));
+const mysql2_1 = require("mysql2");
+class PoolConnection {
+    /**
+     *
+     * @Init a options connection pool
+     */
+    constructor(options) {
+        this.OPTIONS = this._loadOptions();
+        if (options) {
+            this.OPTIONS = new Map(Object.entries(Object.assign(Object.assign({}, Object.fromEntries(this.OPTIONS)), JSON.parse(JSON.stringify(options)))));
+        }
+    }
+    /**
+     *
+     * Get a connection to database
+     * @return {Connection} Connection
+     * @property {Function} Connection.query
+     * @property {Function} Connection.connection
+     */
+    connection() {
+        const pool = (0, mysql2_1.createPool)(Object.fromEntries(this.OPTIONS));
+        if (options_1.default.CONNECTION_ERROR) {
+            pool.getConnection((err, _) => {
+                if (err == null || !err)
+                    return;
+                const message = this._messageError.bind(this);
+                process.nextTick(() => {
+                    console.log(message());
+                    return process.exit();
+                });
+            });
+        }
+        return {
+            query: (sql) => {
+                return new Promise((resolve, reject) => {
+                    pool.query(sql, (err, results) => {
+                        if (err)
+                            return reject(err);
+                        return resolve(results);
+                    });
+                });
+            },
+            connection: () => {
+                return new Promise((resolve, reject) => {
+                    pool.getConnection((err, connection) => {
+                        if (err)
+                            return reject(err);
+                        const query = (sql) => {
+                            return new Promise((resolve, reject) => {
+                                connection.query(sql, (err, result) => {
+                                    if (err)
+                                        return reject(err);
+                                    return resolve(result);
+                                });
+                            });
+                        };
+                        const startTransaction = () => query('START TRANSACTION');
+                        const commit = () => query('COMMIT');
+                        const rollback = () => query('ROLLBACK');
+                        return resolve({
+                            query,
+                            startTransaction,
+                            commit,
+                            rollback
+                        });
+                    });
+                });
+            }
+        };
+    }
+    _defaultOptions() {
+        return new Map(Object.entries({
+            connectionLimit: Number(options_1.default.CONNECTION_LIMIT),
+            dateStrings: Boolean(options_1.default.DATE_STRINGS),
+            connectTimeout: Number(options_1.default.TIMEOUT),
+            waitForConnections: Boolean(options_1.default.WAIT_FOR_CONNECTIONS),
+            queueLimit: Number(options_1.default.QUEUE_LIMIT),
+            multipleStatements: true,
+            charset: String(options_1.default.CHARSET),
+            host: String(options_1.default.HOST),
+            port: Number.isNaN(Number(options_1.default.PORT))
+                ? 3306
+                : Number(options_1.default.PORT),
+            database: String(options_1.default.DATABASE),
+            user: String(options_1.default.USERNAME),
+            password: String(options_1.default.PASSWORD) !== ''
+                ? String(options_1.default.PASSWORD)
+                : ''
+        }));
+    }
+    _loadOptions() {
+        try {
+            /**
+             *
+             * @Json connection
+             *
+                "host"                  : "",
+                "port"                  : "",
+                "database"              : "",
+                "user"                  : "",
+                "password"              : "",
+                "connectionLimit"       : "",
+                "dateStrings"           : "",
+                "idleTimeout"           : "",
+                "waitForConnections"    : "",
+                "queueLimit"            : "",
+                "charset"               : ""
+             */
+            const jsonPath = path_1.default.join(path_1.default.resolve(), 'tspace-mysql.json');
+            const jsonOptionsExists = fs_1.default.existsSync(jsonPath);
+            if (!jsonOptionsExists)
+                return this._defaultOptions();
+            const jsonOptions = fs_1.default.readFileSync(jsonPath, 'utf8');
+            const options = JSON.parse(jsonOptions);
+            return new Map(Object.entries(options));
+        }
+        catch (e) {
+            return this._defaultOptions();
+        }
+    }
+    _messageError() {
         return `
             \x1b[1m\x1b[31m
             Connection lost to database ! \x1b[0m
@@ -137,17 +138,17 @@ class PoolConnection {
                 USERNAME : ${this.OPTIONS.get('user')}          
                 PASSWORD : ${this.OPTIONS.get('password')} \x1b[0m  
             ---------------------------------
-        `;
-    }
-}
-exports.PoolConnection = PoolConnection;
-/**
- *
- * Connection to database when service is started
- * @return {Connection} Connection
- * @property {Function} Connection.query
- * @property {Function} Connection.connection
- */
-const pool = new PoolConnection().connection();
-exports.Pool = pool;
-exports.default = pool;
+        `;
+    }
+}
+exports.PoolConnection = PoolConnection;
+/**
+ *
+ * Connection to database when service is started
+ * @return {Connection} Connection
+ * @property {Function} Connection.query
+ * @property {Function} Connection.connection
+ */
+const pool = new PoolConnection().connection();
+exports.Pool = pool;
+exports.default = pool;

package/dist/lib/connection/options.d.ts

@@ -1,4 +1,15 @@
-declare const _default: Readonly<{
-    [x: string]: any;
-}>;
-export default _default;
+declare const _default: Readonly<{
+    HOST?: string | null | undefined;
+    PORT?: string | number | undefined;
+    USERNAME?: string | undefined;
+    PASSWORD?: string | undefined;
+    DATABASE?: string | undefined;
+    CONNECTION_LIMIT?: string | number | undefined;
+    QUEUE_LIMIT?: string | number | undefined;
+    TIMEOUT?: string | number | undefined;
+    CHARSET?: string | undefined;
+    CONNECTION_ERROR?: string | boolean | undefined;
+    WAIT_FOR_CONNECTIONS?: string | boolean | undefined;
+    DATE_STRINGS?: string | boolean | undefined;
+}>;
+export default _default;

package/dist/lib/connection/options.js

@@ -1,42 +1,43 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const dotenv_1 = __importDefault(require("dotenv"));
-const path_1 = __importDefault(require("path"));
-const fs_1 = __importDefault(require("fs"));
-const environment = () => {
-    var _a;
-    const NODE_ENV = (_a = process.env) === null || _a === void 0 ? void 0 : _a.NODE_ENV;
-    const env = path_1.default.join(path_1.default.resolve(), '.env');
-    const envWithEnviroment = path_1.default.join(path_1.default.resolve(), `.env.${NODE_ENV}`);
-    if (NODE_ENV == null)
-        return env;
-    if (fs_1.default.existsSync(envWithEnviroment))
-        return envWithEnviroment;
-    return env;
-};
-dotenv_1.default.config({ path: environment() });
-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 || 10,
-    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
-};
-for (const [key, value] of Object.entries(env)) {
-    if (value == null)
-        continue;
-    if (typeof value === 'string' && ['true', 'false'].some(v => value.toLowerCase() === v)) {
-        env[key] = JSON.parse(value.toLowerCase());
-    }
-}
-exports.default = Object.freeze(Object.assign({}, env));
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const dotenv_1 = __importDefault(require("dotenv"));
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const environment = () => {
+    var _a;
+    const NODE_ENV = (_a = process.env) === null || _a === void 0 ? void 0 : _a.NODE_ENV;
+    const env = path_1.default.join(path_1.default.resolve(), '.env');
+    if (NODE_ENV == null)
+        return env;
+    const envWithEnviroment = path_1.default.join(path_1.default.resolve(), `.env.${NODE_ENV}`);
+    if (fs_1.default.existsSync(envWithEnviroment))
+        return envWithEnviroment;
+    return env;
+};
+dotenv_1.default.config({ path: environment() });
+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 || 10,
+    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
+};
+for (const [key, value] of Object.entries(env)) {
+    if (value == null)
+        continue;
+    if (typeof value === 'string' && ['true', 'false'].some(v => value.toLowerCase() === v)) {
+        const configEnv = env;
+        configEnv[key] = JSON.parse(value.toLowerCase());
+    }
+}
+exports.default = Object.freeze(Object.assign({}, env));

package/dist/lib/constants/index.d.ts

@@ -1,8 +1,5 @@
-declare const CONSTANTS: {
-    [key: string]: string | Object;
-};
-export { CONSTANTS };
-declare const _default: Readonly<{
-    [key: string]: string | Object;
-}>;
-export default _default;
+declare const CONSTANTS: {
+    [key: string]: string | Object;
+};
+export { CONSTANTS };
+export default CONSTANTS;