@klapeks/micro-db-utils 0.0.12 → 0.0.13

package/dist/sql/commands/tables.commands.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SQLTablesCommands = void 0;
+var column_type_parser_1 = require("../column.type.parser");
+var SQLTablesCommands = /** @class */ (function () {
+    function SQLTablesCommands() {
+    }
+    SQLTablesCommands.tableInfo = function (database, table) {
+        return {
+            toMySQL: function () { return [
+                "SELECT * FROM information_schema.tables",
+                "WHERE table_schema = '".concat(database, "'"),
+                "AND table_name = '".concat(table, "'"),
+                "LIMIT 1;",
+            ].join(' '); },
+            toMSSQL: function () { return [
+                "SELECT TOP 1 * FROM INFORMATION_SCHEMA.TABLES",
+                "WHERE TABLE_CATALOG = '".concat(database, "'"),
+                "AND TABLE_SCHEMA = 'dbo'",
+                "AND TABLE_NAME = '".concat(table, "'"),
+            ].join(' '); },
+        };
+    };
+    SQLTablesCommands.createTable = function (options) {
+        var _createQuery = function (dbtype) {
+            var str = "CREATE TABLE ".concat(options.table, " (");
+            var _index = 0;
+            for (var _i = 0, _a = Object.entries(options.columns); _i < _a.length; _i++) {
+                var _b = _a[_i], columnName = _b[0], columnType = _b[1];
+                if (_index)
+                    str += ', ';
+                _index += 1;
+                if (dbtype === 'mysql')
+                    str += "`".concat(columnName, "` ");
+                else if (dbtype === 'mssql')
+                    str += "[".concat(columnName, "] ");
+                else if (dbtype === 'postgres')
+                    str += "\"".concat(columnName, "\" ");
+                else
+                    str += "".concat(columnName, " ");
+                str += column_type_parser_1.MicroColumnTypeObject.toSQLQuery(dbtype, columnType, 'create-table');
+            }
+            str += ');';
+            return str;
+        };
+        return {
+            toMySQL: function () { return _createQuery('mysql'); },
+            toMSSQL: function () { return _createQuery('mssql'); },
+        };
+    };
+    SQLTablesCommands.getTablesSizes = function (database) {
+        return {
+            toMySQL: function () { return "\n                SELECT \n                    TABLE_NAME as 'table_name', \n                    (DATA_LENGTH / 1024) as 'data_kb', \n                    (INDEX_LENGTH / 1024) as 'index_kb'\n                FROM information_schema.TABLES\n                WHERE table_schema = '".concat(database, "'\n                ORDER BY (data_kb + index_kb) DESC;\n            "); },
+            toMSSQL: function () { return "\n                SELECT\n                    t.name AS table_name,\n                    SUM(ps.in_row_data_page_count + ps.lob_used_page_count\n                        + ps.row_overflow_used_page_count\n                        ) * 8 AS data_kb,\n                    SUM(ps.used_page_count - ps.in_row_data_page_count\n                        - ps.lob_used_page_count - ps.row_overflow_used_page_count\n                        ) * 8 AS index_kb\n                FROM sys.tables t\n                JOIN sys.dm_db_partition_stats ps\n                    ON t.object_id = ps.object_id\n                GROUP BY t.name\n                ORDER BY (data_kb + index_kb) DESC;\n            "; },
+            // postgress
+            // SELECT
+            //     relname AS table_name,
+            //     pg_relation_size(relid) / 1024 AS data_kb,
+            //     pg_indexes_size(relid) / 1024 AS index_kb
+            // FROM pg_catalog.pg_statio_user_tables
+            // ORDER BY pg_total_relation_size(relid) DESC;
+            // sqlite
+            // 1. SELECT
+            //     name AS table_name
+            // FROM sqlite_master
+            // WHERE type = 'table';
+            // 2. SELECT
+            //     SUM(pgsize) / 1024.0 AS data_kb
+            // FROM dbstat
+            // WHERE name = ?;
+        };
+    };
+    return SQLTablesCommands;
+}());
+exports.SQLTablesCommands = SQLTablesCommands;

package/dist/sql/commands/time.commands.d.ts

@@ -0,0 +1,7 @@
+import { DatabaseOptions } from "@klapeks/utils";
+export declare class SQLTimeCommandsExpressions {
+    private readonly dbtype;
+    constructor(dbtype: DatabaseOptions['type']);
+    time(expr: string): string;
+    date(expr: string): string;
+}

package/dist/sql/commands/time.commands.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SQLTimeCommandsExpressions = void 0;
+var SQLTimeCommandsExpressions = /** @class */ (function () {
+    function SQLTimeCommandsExpressions(dbtype) {
+        this.dbtype = dbtype;
+    }
+    SQLTimeCommandsExpressions.prototype.time = function (expr) {
+        if (this.dbtype === 'mssql'
+            || this.dbtype == 'postgres') {
+            return "CAST(".concat(expr, " AS TIME(0))");
+        }
+        return "time(".concat(expr, ")");
+    };
+    SQLTimeCommandsExpressions.prototype.date = function (expr) {
+        if (this.dbtype === 'mssql'
+            || this.dbtype == 'postgres') {
+            return "CAST(".concat(expr, " AS DATE)");
+        }
+        return "time(".concat(expr, ")");
+    };
+    return SQLTimeCommandsExpressions;
+}());
+exports.SQLTimeCommandsExpressions = SQLTimeCommandsExpressions;

package/dist/sql/connections/abstract.connection.d.ts

@@ -0,0 +1,22 @@
+import { DatabaseOptions } from "@klapeks/utils";
+import { AbstractSQLCommand, ISQLCommandAdapter, SQLCommandData } from "../commands";
+export declare abstract class AbstractSQLConnection {
+    readonly rawOptions: DatabaseOptions;
+    readonly abstractCommandFunctionName: keyof ISQLCommandAdapter;
+    protected constructor(rawOptions: DatabaseOptions, abstractCommandFunctionName: keyof ISQLCommandAdapter);
+    get databaseName(): string;
+    abstract initConnection(): Promise<void>;
+    abstract destroyConnection(): Promise<void>;
+    protected abstract sendSQL<T = any>(query: string, params?: any[]): Promise<T[]>;
+    toRawSQL(sql: ISQLCommandAdapter | SQLCommandData | string): SQLCommandData;
+    runSQL<T = any>(query: SQLCommandData): Promise<T[]>;
+    runSQL<T = any>(query: ISQLCommandAdapter): Promise<T[]>;
+    runSQL<T = any>(query: AbstractSQLCommand): Promise<T[]>;
+    runSQL<T = any>(query: string, params?: any): Promise<T[]>;
+    runSQL_One<T = any>(query: SQLCommandData): Promise<T | null>;
+    runSQL_One<T = any>(query: ISQLCommandAdapter): Promise<T | null>;
+    runSQL_One<T = any>(query: AbstractSQLCommand): Promise<T | null>;
+    runSQL_One<T = any>(query: string, params?: any): Promise<T | null>;
+    get isDebugLoggerEnabled(): boolean;
+    protected debugQuery(query: string, params: any): void;
+}

package/dist/sql/connections/abstract.connection.js

@@ -0,0 +1,127 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractSQLConnection = void 0;
+var utils_1 = require("@klapeks/utils");
+var commands_1 = require("../commands");
+var AbstractSQLConnection = /** @class */ (function () {
+    function AbstractSQLConnection(rawOptions, abstractCommandFunctionName) {
+        this.rawOptions = rawOptions;
+        this.abstractCommandFunctionName = abstractCommandFunctionName;
+    }
+    Object.defineProperty(AbstractSQLConnection.prototype, "databaseName", {
+        get: function () {
+            return this.rawOptions.database;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    AbstractSQLConnection.prototype.toRawSQL = function (sql) {
+        return (0, commands_1.toRawSQL)(this.rawOptions.type, sql);
+    };
+    AbstractSQLConnection.prototype.runSQL = function (query, params) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function () {
+            var abstrKey;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!query)
+                            throw "Invalid arg";
+                        if (typeof query === 'string') {
+                            return [2 /*return*/, this.sendSQL(query, params)];
+                        }
+                        if (typeof query !== 'object')
+                            throw "Invalid arg";
+                        abstrKey = this.abstractCommandFunctionName;
+                        if (!(abstrKey in query)) return [3 /*break*/, 2];
+                        return [4 /*yield*/, ((_a = query === null || query === void 0 ? void 0 : query[abstrKey]) === null || _a === void 0 ? void 0 : _a.call(query, {
+                                database: this.databaseName
+                            }))];
+                    case 1:
+                        query = _b.sent();
+                        _b.label = 2;
+                    case 2:
+                        if (!query)
+                            throw "Invalid arg";
+                        if (typeof query === 'object') {
+                            if (!('query' in query))
+                                throw "Invalid arg";
+                            params = query.params || params;
+                            query = query.query;
+                        }
+                        if (typeof query !== 'string')
+                            throw "Invalid arg";
+                        return [2 /*return*/, this.sendSQL(query, params)];
+                }
+            });
+        });
+    };
+    AbstractSQLConnection.prototype.runSQL_One = function (query, params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var res;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.runSQL(query, params)];
+                    case 1:
+                        res = _a.sent();
+                        if (res && Array.isArray(res)) {
+                            return [2 /*return*/, res[0] || null];
+                        }
+                        return [2 /*return*/, res || null];
+                }
+            });
+        });
+    };
+    Object.defineProperty(AbstractSQLConnection.prototype, "isDebugLoggerEnabled", {
+        get: function () {
+            if (this.rawOptions.logging)
+                return true;
+            return process.env['DATABASE_LOG_MICRO_SQL'] == 'true';
+        },
+        enumerable: false,
+        configurable: true
+    });
+    AbstractSQLConnection.prototype.debugQuery = function (query, params) {
+        if (!this.isDebugLoggerEnabled)
+            return;
+        utils_1.logger.log("Running SQL command for " + this.rawOptions.type + ":", utils_1.terminalColors.magenta + query, utils_1.terminalColors.reset, params ? ('\n| with params:') : '', params || '');
+    };
+    return AbstractSQLConnection;
+}());
+exports.AbstractSQLConnection = AbstractSQLConnection;

package/dist/sql/connections/index.d.ts

@@ -0,0 +1,11 @@
+import { DatabaseOptions } from '@klapeks/utils';
+import { AbstractSQLConnection } from './abstract.connection';
+import { MySQLConnection } from './mysql.connection';
+export declare function isDatabaseTypeIs<T extends DatabaseOptions['type']>(options: DatabaseOptions, type: T): options is (DatabaseOptions & {
+    type: T;
+});
+export declare function createSQLConnection(options: DatabaseOptions): AbstractSQLConnection;
+export * from './abstract.connection';
+export * from './mysql.connection';
+export * from './mssql.connection';
+export { MySQLConnection as RawMySQLConnection };

package/dist/sql/connections/index.js

@@ -0,0 +1,35 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RawMySQLConnection = exports.createSQLConnection = exports.isDatabaseTypeIs = void 0;
+var mysql_connection_1 = require("./mysql.connection");
+Object.defineProperty(exports, "RawMySQLConnection", { enumerable: true, get: function () { return mysql_connection_1.MySQLConnection; } });
+var mssql_connection_1 = require("./mssql.connection");
+function isDatabaseTypeIs(options, type) {
+    return options.type === type;
+}
+exports.isDatabaseTypeIs = isDatabaseTypeIs;
+function createSQLConnection(options) {
+    if (isDatabaseTypeIs(options, 'mysql'))
+        return new mysql_connection_1.MySQLConnection(options);
+    if (isDatabaseTypeIs(options, 'mssql'))
+        return new mssql_connection_1.MSSQLConnection(options);
+    throw "Connection for database type " + options.type + ' is not implemented :(';
+}
+exports.createSQLConnection = createSQLConnection;
+__exportStar(require("./abstract.connection"), exports);
+__exportStar(require("./mysql.connection"), exports);
+__exportStar(require("./mssql.connection"), exports);

package/dist/sql/connections/mssql.connection.d.ts

@@ -0,0 +1,15 @@
+import { DatabaseOptions } from '@klapeks/utils';
+import { AbstractSQLConnection } from './abstract.connection';
+import type { ConnectionPool as MSSQL_ConnectionPool, config as MSSQL_ConnectionOptions } from 'mssql';
+export declare class MSSQLConnection extends AbstractSQLConnection {
+    private _pool;
+    readonly poolOptions: MSSQL_ConnectionOptions;
+    constructor(options: DatabaseOptions & {
+        type: "mssql";
+    });
+    initConnection(): Promise<void>;
+    get pool(): MSSQL_ConnectionPool | undefined;
+    getPoolConnection(): Promise<MSSQL_ConnectionPool>;
+    destroyConnection(): Promise<void>;
+    sendSQL<T = any>(query: string, params?: any): Promise<T[]>;
+}

package/dist/sql/connections/mssql.connection.js

@@ -0,0 +1,171 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MSSQLConnection = void 0;
+var utils_1 = require("@klapeks/utils");
+var abstract_connection_1 = require("./abstract.connection");
+var quiet_require_1 = require("../../utils/quiet.require");
+var mssql = (0, quiet_require_1.quietRequire)('mssql');
+var logger = new utils_1.Logger('MSSQL');
+var MSSQLConnection = /** @class */ (function (_super) {
+    __extends(MSSQLConnection, _super);
+    function MSSQLConnection(options) {
+        var _this = _super.call(this, options, 'toMSSQL') || this;
+        _this.poolOptions = {
+            user: options.username,
+            password: options.password,
+            server: options.host,
+            port: options.port,
+            database: options.database,
+            // charset: options.charset,
+            options: options.extra || options.options,
+            pool: {
+                max: 10,
+                min: 0,
+                idleTimeoutMillis: 30000,
+            }
+        };
+        return _this;
+    }
+    MSSQLConnection.prototype.initConnection = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.getPoolConnection()];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    Object.defineProperty(MSSQLConnection.prototype, "pool", {
+        get: function () {
+            return this._pool;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    MSSQLConnection.prototype.getPoolConnection = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!mssql)
+                            throw "mssql module is not installed";
+                        if (this._pool)
+                            return [2 /*return*/, this._pool];
+                        _a = this;
+                        return [4 /*yield*/, new mssql.ConnectionPool(this.poolOptions).connect()];
+                    case 1:
+                        _a._pool = _b.sent();
+                        return [2 /*return*/, this._pool];
+                }
+            });
+        });
+    };
+    MSSQLConnection.prototype.destroyConnection = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                return [2 /*return*/, new Promise(function (resolve, reject) {
+                        if (!_this._pool)
+                            return resolve();
+                        _this._pool.close(function (err) {
+                            _this._pool = undefined;
+                            if (err)
+                                reject(err);
+                            else
+                                resolve();
+                        });
+                    })];
+            });
+        });
+    };
+    MSSQLConnection.prototype.sendSQL = function (query, params) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function () {
+            var connection, request, i, _i, _b, _c, key, value, result;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0: return [4 /*yield*/, this.getPoolConnection()];
+                    case 1:
+                        connection = _d.sent();
+                        request = connection.request();
+                        if (params) {
+                            if (Array.isArray(params) && params.length) {
+                                for (i = 0; i < params.length; i++) {
+                                    query = query.replace('?', '@arg' + i);
+                                    request.input('arg' + i, params[i]);
+                                }
+                            }
+                            else {
+                                for (_i = 0, _b = Object.entries(params); _i < _b.length; _i++) {
+                                    _c = _b[_i], key = _c[0], value = _c[1];
+                                    request.input(key, value);
+                                }
+                            }
+                        }
+                        this.debugQuery(query, params);
+                        return [4 /*yield*/, request.query(query)];
+                    case 2:
+                        result = _d.sent();
+                        return [2 /*return*/, ((_a = result.recordset) !== null && _a !== void 0 ? _a : [])];
+                }
+            });
+        });
+    };
+    return MSSQLConnection;
+}(abstract_connection_1.AbstractSQLConnection));
+exports.MSSQLConnection = MSSQLConnection;

package/dist/{connections → sql/connections}/mysql.connection.d.ts

@@ -1,15 +1,16 @@
 import mysql2 from 'mysql2';
 import { DatabaseOptions } from '@klapeks/utils';
-export declare class RawMySQLConnection {
+import { AbstractSQLConnection } from './abstract.connection';
+export declare class MySQLConnection extends AbstractSQLConnection {
     private _pool;
     readonly poolOptions: mysql2.PoolOptions;
     constructor(options: DatabaseOptions & {
         type: "mysql";
     });
+    initConnection(): Promise<void>;
     get pool(): mysql2.Pool | undefined;
     takePool(): Promise<mysql2.Pool>;
     destroyConnection(): Promise<void>;
-    getConnection(): Promise<mysql2.PoolConnection>;
-    runSQL<T = any>(query: string, params?: any[]): Promise<T[]>;
-    runSQL_One<T = any>(query: string, params?: any[]): Promise<T | null>;
+    getPoolConnection(): Promise<mysql2.PoolConnection>;
+    sendSQL<T = any>(query: string, params?: any): Promise<T[]>;
 }

package/dist/{connections → sql/connections}/mysql.connection.js

@@ -1,4 +1,19 @@
 "use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -39,13 +54,16 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RawMySQLConnection = void 0;
+exports.MySQLConnection = void 0;
 var mysql2_1 = __importDefault(require("mysql2"));
 var utils_1 = require("@klapeks/utils");
+var abstract_connection_1 = require("./abstract.connection");
 var logger = new utils_1.Logger('MySQL');
-var RawMySQLConnection = /** @class */ (function () {
-    function RawMySQLConnection(options) {
-        this.poolOptions = {
+var MySQLConnection = /** @class */ (function (_super) {
+    __extends(MySQLConnection, _super);
+    function MySQLConnection(options) {
+        var _this = _super.call(this, options, 'toMySQL') || this;
+        _this.poolOptions = {
             user: options.username,
             password: options.password,
             host: options.host,
@@ -53,15 +71,28 @@ var RawMySQLConnection = /** @class */ (function () {
             database: options.database,
             charset: options.charset,
         };
+        return _this;
     }
-    Object.defineProperty(RawMySQLConnection.prototype, "pool", {
+    MySQLConnection.prototype.initConnection = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.takePool()];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    Object.defineProperty(MySQLConnection.prototype, "pool", {
         get: function () {
             return this._pool;
         },
         enumerable: false,
         configurable: true
     });
-    RawMySQLConnection.prototype.takePool = function () {
+    MySQLConnection.prototype.takePool = function () {
         return __awaiter(this, void 0, void 0, function () {
             var _this = this;
             return __generator(this, function (_a) {
@@ -82,7 +113,7 @@ var RawMySQLConnection = /** @class */ (function () {
             });
         });
     };
-    RawMySQLConnection.prototype.destroyConnection = function () {
+    MySQLConnection.prototype.destroyConnection = function () {
         return __awaiter(this, void 0, void 0, function () {
             var _this = this;
             return __generator(this, function (_a) {
@@ -100,7 +131,7 @@ var RawMySQLConnection = /** @class */ (function () {
             });
         });
     };
-    RawMySQLConnection.prototype.getConnection = function () {
+    MySQLConnection.prototype.getPoolConnection = function () {
         return __awaiter(this, void 0, void 0, function () {
             var _a;
             var _this = this;
@@ -126,16 +157,17 @@ var RawMySQLConnection = /** @class */ (function () {
             });
         });
     };
-    RawMySQLConnection.prototype.runSQL = function (query, params) {
+    MySQLConnection.prototype.sendSQL = function (query, params) {
         return __awaiter(this, void 0, void 0, function () {
             var connection;
+            var _this = this;
             return __generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.getConnection()];
+                    case 0: return [4 /*yield*/, this.getPoolConnection()];
                     case 1:
                         connection = _a.sent();
                         return [2 /*return*/, new Promise(function (resolve, reject) {
-                                // logger.debug("SQL query: ", query, '| params:', params||[])
+                                _this.debugQuery(query, params);
                                 connection.query(query, params || [], function (err, result) {
                                     connection.release();
                                     if (err)
@@ -147,19 +179,6 @@ var RawMySQLConnection = /** @class */ (function () {
             });
         });
     };
-    RawMySQLConnection.prototype.runSQL_One = function (query, params) {
-        return __awaiter(this, void 0, void 0, function () {
-            var res;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.runSQL(query, params)];
-                    case 1:
-                        res = _a.sent();
-                        return [2 /*return*/, res.length ? (res[0] || res) : null];
-                }
-            });
-        });
-    };
-    return RawMySQLConnection;
-}());
-exports.RawMySQLConnection = RawMySQLConnection;
+    return MySQLConnection;
+}(abstract_connection_1.AbstractSQLConnection));
+exports.MySQLConnection = MySQLConnection;

package/dist/sql/index.d.ts

@@ -0,0 +1,2 @@
+export * from './commands';
+export * from './connections';