@klapeks/micro-db-utils 0.0.17 → 0.0.20

package/dist/index.d.ts

@@ -4,3 +4,4 @@ export * from './sql';
 export * from './connections';
 export * from './migrations';
 export * from './selectors';
+export * from './patch.typeorm';

package/dist/index.js

@@ -20,3 +20,4 @@ __exportStar(require("./sql"), exports);
 __exportStar(require("./connections"), exports);
 __exportStar(require("./migrations"), exports);
 __exportStar(require("./selectors"), exports);
+__exportStar(require("./patch.typeorm"), exports);

package/dist/micro.sql.js

@@ -57,7 +57,12 @@ var MicroSQL;
                         _b.label = 3;
                     case 3:
                         query = (_a);
-                        query = (0, sql_1.toRawSQL)(dbType, query);
+                        return [4 /*yield*/, (0, sql_1.toRawSQL)(dbType, query, {
+                                database: dataSource.options.database,
+                                runAdditionalSQL: dataSource.query
+                            })];
+                    case 4:
+                        query = _b.sent();
                         return [2 /*return*/, dataSource.query(query.query, query.params)];
                 }
             });

package/dist/migrations/super.migrations.js

@@ -104,29 +104,34 @@ var SuperMigrations = /** @class */ (function () {
                     case 1: return [4 /*yield*/, _e.sent()];
                     case 2:
                         isTableExistsInfo = _e.sent();
-                        if (!!isTableExistsInfo) return [3 /*break*/, 5];
-                        firstSQL = (function () {
-                            var _a;
-                            var sql = (_a = todoMigrations === null || todoMigrations === void 0 ? void 0 : todoMigrations[0]) === null || _a === void 0 ? void 0 : _a.sql;
-                            if (!sql)
-                                return null;
-                            if (Array.isArray(sql))
-                                sql = sql[0];
-                            return sqlInstance.toRawSQL(sql);
-                        })();
-                        if (!!((_b = (_a = firstSQL === null || firstSQL === void 0 ? void 0 : firstSQL.query) === null || _a === void 0 ? void 0 : _a.toLowerCase()) === null || _b === void 0 ? void 0 : _b.includes('create table'))) return [3 /*break*/, 5];
+                        if (!!isTableExistsInfo) return [3 /*break*/, 6];
+                        return [4 /*yield*/, (function () { return __awaiter(_this, void 0, void 0, function () {
+                                var sql;
+                                var _a;
+                                return __generator(this, function (_b) {
+                                    sql = (_a = todoMigrations === null || todoMigrations === void 0 ? void 0 : todoMigrations[0]) === null || _a === void 0 ? void 0 : _a.sql;
+                                    if (!sql)
+                                        return [2 /*return*/, null];
+                                    if (Array.isArray(sql))
+                                        sql = sql[0];
+                                    return [2 /*return*/, sqlInstance.toRawSQL(sql)];
+                                });
+                            }); })()];
+                    case 3:
+                        firstSQL = _e.sent();
+                        if (!!((_b = (_a = firstSQL === null || firstSQL === void 0 ? void 0 : firstSQL.query) === null || _a === void 0 ? void 0 : _a.toLowerCase()) === null || _b === void 0 ? void 0 : _b.includes('create table'))) return [3 /*break*/, 6];
                         logger.log("Table ".concat(table, " not found. Migrations ").concat(todoMigrations === null || todoMigrations === void 0 ? void 0 : todoMigrations.length, " will be skipped"));
                         lastMigrationDate = todoMigrations.length ? (_c = todoMigrations === null || todoMigrations === void 0 ? void 0 : todoMigrations[todoMigrations.length - 1]) === null || _c === void 0 ? void 0 : _c.date : undefined;
-                        if (!((todoMigrations === null || todoMigrations === void 0 ? void 0 : todoMigrations.length) && lastMigrationDate)) return [3 /*break*/, 4];
+                        if (!((todoMigrations === null || todoMigrations === void 0 ? void 0 : todoMigrations.length) && lastMigrationDate)) return [3 /*break*/, 5];
                         return [4 /*yield*/, sqlInstance.runSQL(micro_sql_1.MicroSQL.editData(this.migrationTableName).upsert({
                                 table: table,
                                 lastMigrationTime: (0, iso_date_time_1.toISODate)(lastMigrationDate)
                             }, ['table']))];
-                    case 3:
+                    case 4:
                         _e.sent();
-                        _e.label = 4;
-                    case 4: return [2 /*return*/];
-                    case 5:
+                        _e.label = 5;
+                    case 5: return [2 /*return*/];
+                    case 6:
                         _local_runSQL = function (sql, params) { return __awaiter(_this, void 0, void 0, function () {
                             return __generator(this, function (_a) {
                                 switch (_a.label) {
@@ -155,61 +160,71 @@ var SuperMigrations = /** @class */ (function () {
                         lastRealMigration = lastRealMigrationDateTime
                             ? new Date(lastRealMigrationDateTime) : null;
                         _i = 0, todoMigrations_1 = todoMigrations;
-                        _e.label = 6;
-                    case 6:
-                        if (!(_i < todoMigrations_1.length)) return [3 /*break*/, 17];
+                        _e.label = 7;
+                    case 7:
+                        if (!(_i < todoMigrations_1.length)) return [3 /*break*/, 20];
                         migration = todoMigrations_1[_i];
                         if (migration.table != table)
-                            return [3 /*break*/, 16];
+                            return [3 /*break*/, 19];
                         logger;
                         if (lastRealMigration && lastRealMigration.getTime() >= migration.date.getTime()) {
-                            return [3 /*break*/, 16];
+                            return [3 /*break*/, 19];
                         }
                         runnedMigrationsAmount = onMigrationComplete();
                         migrationName = '"' + table + ' ' + (0, iso_date_time_1.toISODate)(migration.date) + '"';
-                        if (!Array.isArray(migration.sql)) return [3 /*break*/, 11];
-                        sqls = migration.sql.filter(Boolean).map(function (sql) {
-                            var sql2 = sqlInstance.toRawSQL(sql);
-                            sql2.query = utils_1.utils.replaceAll(sql2.query.trim(), "%{table_name}", table);
-                            return sql2;
-                        });
+                        if (!Array.isArray(migration.sql)) return [3 /*break*/, 13];
+                        return [4 /*yield*/, Promise.all(migration.sql.filter(Boolean).map(function (sql) { return __awaiter(_this, void 0, void 0, function () {
+                                var sql2;
+                                return __generator(this, function (_a) {
+                                    switch (_a.label) {
+                                        case 0: return [4 /*yield*/, sqlInstance.toRawSQL(sql)];
+                                        case 1:
+                                            sql2 = _a.sent();
+                                            sql2.query = utils_1.utils.replaceAll(sql2.query.trim(), "%{table_name}", table);
+                                            return [2 /*return*/, sql2];
+                                    }
+                                });
+                            }); }))];
+                    case 8:
+                        sqls = _e.sent();
                         logger.log(runnedMigrationsAmount, "| Migrations will be runned:", migrationName, '|\n' + utils_1.terminalColors.cyan, sqls.map(function (s) { return s.query; }));
                         _d = 0, sqls_1 = sqls;
-                        _e.label = 7;
-                    case 7:
-                        if (!(_d < sqls_1.length)) return [3 /*break*/, 10];
+                        _e.label = 9;
+                    case 9:
+                        if (!(_d < sqls_1.length)) return [3 /*break*/, 12];
                         sql = sqls_1[_d];
                         return [4 /*yield*/, _local_runSQL(sql.query, sql.params)];
-                    case 8:
+                    case 10:
                         _e.sent();
-                        _e.label = 9;
-                    case 9:
-                        _d++;
-                        return [3 /*break*/, 7];
-                    case 10: return [3 /*break*/, 13];
+                        _e.label = 11;
                     case 11:
-                        sql = sqlInstance.toRawSQL(migration.sql);
+                        _d++;
+                        return [3 /*break*/, 9];
+                    case 12: return [3 /*break*/, 16];
+                    case 13: return [4 /*yield*/, sqlInstance.toRawSQL(migration.sql)];
+                    case 14:
+                        sql = _e.sent();
                         sql.query = utils_1.utils.replaceAll(sql.query.trim(), "%{table_name}", table);
                         logger.log(runnedMigrationsAmount, "| Migration will be runned:", migrationName, '|\n' + utils_1.terminalColors.cyan, sql.query);
                         return [4 /*yield*/, _local_runSQL(sql.query, sql.params)];
-                    case 12:
+                    case 15:
                         _e.sent();
-                        _e.label = 13;
-                    case 13: return [4 /*yield*/, sqlInstance.runSQL(micro_sql_1.MicroSQL.editData(this.migrationTableName).upsert({
+                        _e.label = 16;
+                    case 16: return [4 /*yield*/, sqlInstance.runSQL(micro_sql_1.MicroSQL.editData(this.migrationTableName).upsert({
                             table: table,
                             lastMigrationTime: (0, iso_date_time_1.toISODate)(migration.date)
                         }, ['table']))];
-                    case 14:
+                    case 17:
                         _e.sent();
                         logger.log(runnedMigrationsAmount, "| Migration", migrationName, "successfully done");
                         return [4 /*yield*/, utils_1.utils.sleep(100)];
-                    case 15:
+                    case 18:
                         _e.sent();
-                        _e.label = 16;
-                    case 16:
+                        _e.label = 19;
+                    case 19:
                         _i++;
-                        return [3 /*break*/, 6];
-                    case 17: return [2 /*return*/];
+                        return [3 /*break*/, 7];
+                    case 20: return [2 /*return*/];
                 }
             });
         });

package/dist/patch.typeorm.d.ts

@@ -0,0 +1 @@
+export declare function patchTypeorm(): void;

package/dist/patch.typeorm.js

@@ -0,0 +1,129 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+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.patchTypeorm = void 0;
+var typeorm_1 = require("typeorm");
+var _alreadyPatched = false;
+function patchTypeorm() {
+    if (_alreadyPatched)
+        return;
+    { // repository changes
+        var originalUpdate_1 = typeorm_1.Repository.prototype.update;
+        typeorm_1.Repository.prototype.update = function () {
+            var args = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                args[_i] = arguments[_i];
+            }
+            var _wasDel = false;
+            for (var _a = 0, _b = Object.keys(args[0]); _a < _b.length; _a++) {
+                var key = _b[_a];
+                if (typeof args[1] === 'object' && key in args[1]) {
+                    if (args[0][key] === args[1][key]) {
+                        if (!_wasDel) {
+                            args[1] = __assign({}, args[1]);
+                            _wasDel = true;
+                        }
+                        delete args[1][key];
+                    }
+                }
+            }
+            return originalUpdate_1.apply(this, args);
+        };
+        var originalUpsert_1 = typeorm_1.Repository.prototype.upsert;
+        typeorm_1.Repository.prototype.upsert = function () {
+            var args = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                args[_i] = arguments[_i];
+            }
+            return __awaiter(this, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    if (this.manager.connection.options.type === "mssql") {
+                        return [2 /*return*/, this.save(args[0])];
+                    }
+                    return [2 /*return*/, originalUpsert_1.apply(this, args)];
+                });
+            });
+        };
+    }
+    { // query builder changes changes
+        var whereFix_1 = function (dbtype, args) {
+            if (args[0] && typeof args[0] === 'string') {
+                if (dbtype == 'mssql') {
+                    args[0] = args[0].replace(/\btrue\b/g, "1");
+                    args[0] = args[0].replace(/\bfalse\b/g, "0");
+                }
+            }
+            return args;
+        };
+        var originalWhere_1 = typeorm_1.SelectQueryBuilder.prototype.where;
+        typeorm_1.SelectQueryBuilder.prototype.where = function () {
+            var _a;
+            var args = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                args[_i] = arguments[_i];
+            }
+            var dbType = this.connection.options.type
+                || ((_a = this.dataSource) === null || _a === void 0 ? void 0 : _a.options.type);
+            return originalWhere_1.apply(this, whereFix_1(dbType, args));
+        };
+        var originalAndWhere_1 = typeorm_1.SelectQueryBuilder.prototype.andWhere;
+        typeorm_1.SelectQueryBuilder.prototype.andWhere = function () {
+            var _a;
+            var args = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                args[_i] = arguments[_i];
+            }
+            var dbType = this.connection.options.type
+                || ((_a = this.dataSource) === null || _a === void 0 ? void 0 : _a.options.type);
+            return originalAndWhere_1.apply(this, whereFix_1(dbType, args));
+        };
+    }
+    _alreadyPatched = true;
+}
+exports.patchTypeorm = patchTypeorm;

package/dist/sql/column.type.parser.d.ts

@@ -1,6 +1,6 @@
-import { DatabaseOptions } from "@klapeks/utils";
+import { DatabaseOptions, getRawDatabaseColumnTypeOfTypeORM } from "@klapeks/utils";
 import { ColumnType } from "typeorm";
-export declare function getRawDatabaseColumnTypeOfTypeORM(dbtype: DatabaseOptions['type'], type: ColumnType): ColumnType;
+export { getRawDatabaseColumnTypeOfTypeORM };
 export interface MicroColumnTypeObject {
     type: ColumnType;
     primary?: boolean;

package/dist/sql/column.type.parser.js

@@ -1,40 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MicroColumnTypeObject = exports.getRawDatabaseColumnTypeOfTypeORM = void 0;
-var utils_1 = require("../utils");
-// https://vscode.dev/github.com/typeorm/typeorm/blob/master/src/driver/mysql/MysqlDriver.ts#L750
-// https://vscode.dev/github.com/typeorm/typeorm/blob/master/src/driver/sqlserver/SqlServerDriver.ts#L678
-function getRawDatabaseColumnTypeOfTypeORM(dbtype, type) {
-    if (type === Number) {
-        if (dbtype == 'sqlite')
-            return 'integer';
-        if (dbtype == 'postgres')
-            return 'integer';
-        return 'int';
-    }
-    if (type === String) {
-        if (dbtype === 'postgres')
-            return 'character varying';
-        if (dbtype === 'mssql')
-            return 'nvarchar';
-        return 'varchar';
-    }
-    if (type === Boolean) {
-        if (dbtype === 'mssql')
-            return 'bit';
-        if (dbtype === 'mysql')
-            return 'tinyint';
-        return 'boolean';
-    }
-    if (type === Date)
-        return utils_1.MULTISQL_COLUMNS_TYPES.datetime;
-    return type;
-}
-exports.getRawDatabaseColumnTypeOfTypeORM = getRawDatabaseColumnTypeOfTypeORM;
+var utils_1 = require("@klapeks/utils");
+Object.defineProperty(exports, "getRawDatabaseColumnTypeOfTypeORM", { enumerable: true, get: function () { return utils_1.getRawDatabaseColumnTypeOfTypeORM; } });
 var MicroColumnTypeObject;
 (function (MicroColumnTypeObject) {
     function toSQLQuery(dbType, options, queryType) {
-        var columnType = getRawDatabaseColumnTypeOfTypeORM(dbType, options.type);
+        var columnType = (0, utils_1.getRawDatabaseColumnTypeOfTypeORM)(dbType, options.type);
         var columnLength = options.length || ((columnType === 'varchar'
             || columnType === 'nvarchar') ? 255 : undefined);
         var str = columnType + (columnLength ? "(".concat(columnLength, ")") : '');
@@ -49,6 +21,7 @@ var MicroColumnTypeObject;
                 str += ' IDENTITY';
             else if (dbType === 'mysql')
                 str += ' AUTO_INCREMENT';
+            else if (dbType === 'sqlite') { /** after primary key */ }
             else
                 throw "options.generated is not supported yet for " + dbType;
         }
@@ -85,6 +58,9 @@ var MicroColumnTypeObject;
             if (options.primary) {
                 str += ' PRIMARY KEY';
             }
+            if (dbType === 'sqlite' && options.generated) {
+                str += ' AUTOINCREMENT';
+            }
         }
         return str;
     }

package/dist/sql/commands/abstract.sql.command.d.ts

@@ -4,18 +4,23 @@ export interface SQLCommandData {
     params?: any[];
 }
 export interface SQLCommandContext {
+    database: string;
+    runAdditionalSQL: (sql: string, params?: any[]) => any;
 }
 export interface ISQLCommandAdapter {
-    toMySQL(ctx?: SQLCommandContext): SQLCommandData | string;
-    toMSSQL(ctx?: SQLCommandContext): SQLCommandData | string;
+    toMySQL(ctx?: SQLCommandContext): SQLCommandData | string | Promise<string>;
+    toMSSQL(ctx?: SQLCommandContext): SQLCommandData | string | Promise<string>;
+    toSQLite(ctx?: SQLCommandContext): SQLCommandData | string | Promise<string>;
 }
 export declare abstract class AbstractSQLCommand implements ISQLCommandAdapter {
-    abstract toMySQL(ctx?: SQLCommandContext): SQLCommandData | string;
-    abstract toMSSQL(ctx?: SQLCommandContext): SQLCommandData | string;
+    abstract toMySQL(ctx?: SQLCommandContext): SQLCommandData | string | Promise<string>;
+    abstract toMSSQL(ctx?: SQLCommandContext): SQLCommandData | string | Promise<string>;
+    abstract toSQLite(ctx?: SQLCommandContext): SQLCommandData | string | Promise<string>;
 }
 export declare const rawSQL: (sqls: {
     defaultQuery: string;
     mysqlQuery?: string;
     mssqlQuery?: string;
+    sqliteQuery?: string;
 }) => ISQLCommandAdapter;
-export declare function toRawSQL(dbType: DatabaseOptions['type'], query: ISQLCommandAdapter | SQLCommandData | string): SQLCommandData;
+export declare function toRawSQL(dbType: DatabaseOptions['type'], query: ISQLCommandAdapter | SQLCommandData | string, ctx?: SQLCommandContext): Promise<SQLCommandData>;

package/dist/sql/commands/abstract.sql.command.js

@@ -1,4 +1,40 @@
 "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.toRawSQL = exports.rawSQL = exports.AbstractSQLCommand = void 0;
 var AbstractSQLCommand = /** @class */ (function () {
@@ -11,20 +47,39 @@ var rawSQL = function (sqls) {
     return {
         toMySQL: function () { return sqls.mysqlQuery || sqls.defaultQuery; },
         toMSSQL: function () { return sqls.mssqlQuery || sqls.defaultQuery; },
+        toSQLite: function () { return sqls.sqliteQuery || sqls.defaultQuery; },
     };
 };
 exports.rawSQL = rawSQL;
-function toRawSQL(dbType, query) {
-    if (typeof query === 'string')
-        return { query: query };
-    if (typeof query === 'object' && !('query' in query)) {
-        if (dbType === 'mysql')
-            query = query.toMySQL({});
-        else if (dbType === 'mssql')
-            query = query.toMSSQL({});
-        else
-            throw "Unknown database type: " + dbType;
-    }
-    return typeof query === 'string' ? { query: query } : query;
+function toRawSQL(dbType, query, ctx) {
+    return __awaiter(this, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (typeof query === 'string')
+                        return [2 /*return*/, { query: query }];
+                    if (!(typeof query === 'object' && !('query' in query))) return [3 /*break*/, 7];
+                    if (!(dbType === 'mysql')) return [3 /*break*/, 2];
+                    return [4 /*yield*/, query.toMySQL(ctx)];
+                case 1:
+                    query = _a.sent();
+                    return [3 /*break*/, 7];
+                case 2:
+                    if (!(dbType === 'mssql')) return [3 /*break*/, 4];
+                    return [4 /*yield*/, query.toMSSQL(ctx)];
+                case 3:
+                    query = _a.sent();
+                    return [3 /*break*/, 7];
+                case 4:
+                    if (!(dbType === 'sqlite')) return [3 /*break*/, 6];
+                    return [4 /*yield*/, query.toSQLite(ctx)];
+                case 5:
+                    query = _a.sent();
+                    return [3 /*break*/, 7];
+                case 6: throw "Unknown database type: " + dbType;
+                case 7: return [2 /*return*/, typeof query === 'string' ? { query: query } : query];
+            }
+        });
+    });
 }
 exports.toRawSQL = toRawSQL;

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

@@ -5,6 +5,6 @@ export declare class SQLAlterCommand {
     constructor(table: string);
     array(cb: (t: SQLAlterCommand) => ISQLCommandAdapter[]): ISQLCommandAdapter[];
     renameColumn(old_name: string, new_name: string): ISQLCommandAdapter;
-    changeColumnType(column: string, type: MicroColumnTypeObject): ISQLCommandAdapter;
     addColumn(column: string, type: MicroColumnTypeObject): ISQLCommandAdapter;
+    changeColumnType(column: string, type: MicroColumnTypeObject): ISQLCommandAdapter;
 }

package/dist/sql/commands/alter.commands.js

@@ -1,6 +1,43 @@
 "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.SQLAlterCommand = void 0;
+var utils_1 = require("@klapeks/utils");
 var column_type_parser_1 = require("../column.type.parser");
 var SQLAlterCommand = /** @class */ (function () {
     function SQLAlterCommand(table) {
@@ -13,25 +50,92 @@ var SQLAlterCommand = /** @class */ (function () {
         var _this = this;
         return {
             toMySQL: function () { return "ALTER TABLE `".concat(_this.table, "` RENAME COLUMN `").concat(old_name, "` TO `").concat(new_name, "`;"); },
-            toMSSQL: function () { return "EXEC sp_rename '".concat(_this.table, ".").concat(old_name, "', '").concat(new_name, "', 'COLUMN';"); }
+            toMSSQL: function () { return "EXEC sp_rename '".concat(_this.table, ".").concat(old_name, "', '").concat(new_name, "', 'COLUMN';"); },
+            toSQLite: function () { return "ALTER TABLE \"".concat(_this.table, "\" RENAME COLUMN \"").concat(old_name, "\" TO \"").concat(new_name, "\";"); },
         };
     };
-    SQLAlterCommand.prototype.changeColumnType = function (column, type) {
+    SQLAlterCommand.prototype.addColumn = function (column, type) {
         var _this = this;
         return {
-            toMySQL: function () { return "ALTER TABLE `".concat(_this.table, "` MODIFY COLUMN `").concat(column, "` ")
+            toMySQL: function () { return "ALTER TABLE `".concat(_this.table, "` ADD COLUMN `").concat(column, "` ")
                 + column_type_parser_1.MicroColumnTypeObject.toSQLQuery('mysql', type, 'alter-column') + ';'; },
-            toMSSQL: function () { return "ALTER TABLE [".concat(_this.table, "] ALTER COLUMN [").concat(column, "] ")
-                + column_type_parser_1.MicroColumnTypeObject.toSQLQuery('mssql', type, 'alter-column') + ';'; }
+            toMSSQL: function () { return "ALTER TABLE [".concat(_this.table, "] ADD [").concat(column, "] ")
+                + column_type_parser_1.MicroColumnTypeObject.toSQLQuery('mssql', type, 'alter-column') + ';'; },
+            toSQLite: function () { return "ALTER TABLE \"".concat(_this.table, "\" ADD COLUMN \"").concat(column, "\" ")
+                + column_type_parser_1.MicroColumnTypeObject.toSQLQuery("sqlite", type, "alter-column") + ";"; }
         };
     };
-    SQLAlterCommand.prototype.addColumn = function (column, type) {
+    SQLAlterCommand.prototype.changeColumnType = function (column, type) {
         var _this = this;
         return {
-            toMySQL: function () { return "ALTER TABLE `".concat(_this.table, "` ADD COLUMN `").concat(column, "` ")
+            toMySQL: function () { return "ALTER TABLE `".concat(_this.table, "` MODIFY COLUMN `").concat(column, "` ")
                 + column_type_parser_1.MicroColumnTypeObject.toSQLQuery('mysql', type, 'alter-column') + ';'; },
-            toMSSQL: function () { return "ALTER TABLE [".concat(_this.table, "] ADD [").concat(column, "] ")
-                + column_type_parser_1.MicroColumnTypeObject.toSQLQuery('mssql', type, 'alter-column') + ';'; }
+            toMSSQL: function () { return "ALTER TABLE [".concat(_this.table, "] ALTER COLUMN [").concat(column, "] ")
+                + column_type_parser_1.MicroColumnTypeObject.toSQLQuery('mssql', type, 'alter-column') + ';'; },
+            toSQLite: function (ctx) { return __awaiter(_this, void 0, void 0, function () {
+                var tableCreateOld, indexesToRecreate, tableCreateArray, _wasChanges, tableColumnNames, _loop_1, i, RECHANGE_TABLE_NAME;
+                var _a, _b;
+                return __generator(this, function (_c) {
+                    switch (_c.label) {
+                        case 0:
+                            if (!(ctx === null || ctx === void 0 ? void 0 : ctx.runAdditionalSQL))
+                                throw "No runAdditionalSQL in context";
+                            return [4 /*yield*/, ctx.runAdditionalSQL("\n                    SELECT sql FROM sqlite_master WHERE type = \"table\" AND name = \"".concat(this.table, "\";\n                "))];
+                        case 1:
+                            tableCreateOld = (_b = (_a = (_c.sent())) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.sql;
+                            if (!tableCreateOld)
+                                throw "Table ".concat(this.table, " not exists");
+                            return [4 /*yield*/, ctx.runAdditionalSQL("\n                    SELECT sql FROM sqlite_master WHERE type = \"index\"\n                    AND tbl_name = \"".concat(this.table, "\" AND sql IS NOT NULL;\n                "))];
+                        case 2:
+                            indexesToRecreate = (_c.sent()).map(function (s) { return s.sql || s; }).filter(Boolean).join("; ") + ';';
+                            tableCreateArray = tableCreateOld.split('\n');
+                            _wasChanges = false;
+                            tableColumnNames = [];
+                            _loop_1 = function (i) {
+                                if (tableCreateArray[i].trim()[0] == '"') {
+                                    var str = tableCreateArray[i].trim().substring(1);
+                                    tableColumnNames.push(str.substring(0, str.indexOf('"')));
+                                }
+                                if (!tableCreateArray[i].includes('"' + column + '"'))
+                                    return "continue";
+                                var arr = tableCreateArray[i].split('\t');
+                                var indexName = arr.findIndex(function (a) { return a == '"' + column + '"'; });
+                                if (indexName < 0)
+                                    return "continue";
+                                arr[indexName + 1] = (function () {
+                                    var str = column_type_parser_1.MicroColumnTypeObject.toSQLQuery('sqlite', type);
+                                    if (str.startsWith('text('))
+                                        str = str.replace("text(", "varchar(");
+                                    if (arr[indexName + 1].toLowerCase().includes(' unique'))
+                                        str += ' UNIQUE';
+                                    if (arr[indexName + 1].endsWith(','))
+                                        str += ',';
+                                    return str;
+                                })();
+                                // console.log("CHANGES ARR:", arr);
+                                tableCreateArray[i] = arr.join('\t');
+                                _wasChanges = true;
+                            };
+                            for (i = 0; i < tableCreateArray.length; i++) {
+                                _loop_1(i);
+                            }
+                            if (!_wasChanges)
+                                return [2 /*return*/, "SELECT 1"];
+                            RECHANGE_TABLE_NAME = this.table + "___rechange_" + utils_1.utils.randomInclude(99);
+                            tableCreateArray[0] = "CREATE TABLE \"".concat(RECHANGE_TABLE_NAME, "\" (");
+                            // console.log("Table create:", tableCreateNew);
+                            // console.log("INDEXES:", indexesToRecreate);
+                            // console.log("Colums:", tableColumnNames);
+                            // const hasColumnIndex = tableColumns.findIndex(
+                            //     (row) => row.name === column
+                            // );
+                            // if (hasColumnIndex < 0) return "SELECT 1";
+                            // // ctx?.runAdditionalSQL
+                            // // throw "Not implemented yet: changeColumnType for sqlite"
+                            return [2 /*return*/, "\n                    BEGIN;\n                    ".concat(tableCreateArray.join('\n'), ";\n                    INSERT INTO ").concat(RECHANGE_TABLE_NAME, " (").concat(tableColumnNames.join(', '), ") \n                        SELECT ").concat(tableColumnNames.join(', '), " FROM ").concat(this.table, ";\n                    DROP TABLE ").concat(this.table, ";\n                    ALTER TABLE ").concat(RECHANGE_TABLE_NAME, " RENAME TO ").concat(this.table, ";\n                    ").concat(indexesToRecreate, "\n                    COMMIT;\n                ")];
+                    }
+                });
+            }); },
         };
     };
     return SQLAlterCommand;

package/dist/sql/commands/edit-data.commands.d.ts

@@ -2,6 +2,7 @@ import { ISQLCommandAdapter } from "./abstract.sql.command";
 export declare class SQLEditDataCommands {
     private readonly table;
     constructor(table: string);
+    insert(data: any): ISQLCommandAdapter;
     update(data: any, where: any): ISQLCommandAdapter;
     upsert(data: any, idKeys: string[]): ISQLCommandAdapter;
 }

package/dist/sql/commands/edit-data.commands.js

@@ -26,15 +26,35 @@ var SQLEditDataCommands = /** @class */ (function () {
     function SQLEditDataCommands(table) {
         this.table = table;
     }
+    SQLEditDataCommands.prototype.insert = function (data) {
+        var _this = this;
+        if (!data)
+            throw "No data param";
+        var dataKeys = Object.keys(data);
+        return {
+            toMySQL: function () { return ({
+                query: "\n                    INSERT INTO `".concat(_this.table, "` \n                    (").concat(dataKeys.map(function (key) { return "`".concat(key, "`"); }).join(', '), ") \n                    VALUES (").concat(dataKeys.map(function () { return '?'; }).join(', '), ");\n                "),
+                params: Object.values(data),
+            }); },
+            toMSSQL: function () { return ({
+                query: "\n                    INSERT INTO [".concat(_this.table, "]\n                    (").concat(dataKeys.map(function (key) { return "[".concat(key, "]"); }).join(', '), ")\n                    VALUES (").concat(dataKeys.map(function (key) { return '@' + key; }).join(', '), ");\n                "),
+                params: data,
+            }); },
+            toSQLite: function () { return ({
+                query: "\n                    INSERT INTO \"".concat(_this.table, "\" \n                    (").concat(dataKeys.map(function (key) { return "\"".concat(key, "\""); }).join(', '), ") \n                    VALUES (").concat(dataKeys.map(function () { return '?'; }).join(', '), ");\n                "),
+                params: Object.values(data),
+            }); },
+        };
+    };
     SQLEditDataCommands.prototype.update = function (data, where) {
         var _this = this;
         return {
             toMySQL: function () { return ({
-                query: "\n                    UPDATE `".concat(_this.table, "`\n                    SET ").concat(Object.keys(data).map(function (key) { return "`".concat(key, "` = ?"); }).join(','), "\n                    WHERE ").concat(Object.keys(where).map(function (key) { return (0, raw_where_utils_1.converWhereQuery)('mysql', key, data[key], '?'); }).join(' AND '), ";\n                "),
+                query: "\n                    UPDATE `".concat(_this.table, "`\n                    SET ").concat(Object.keys(data).map(function (key) { return "`".concat(key, "` = ?"); }).join(', '), "\n                    WHERE ").concat(Object.keys(where).map(function (key) { return (0, raw_where_utils_1.converWhereQuery)('mysql', key, data[key], '?'); }).join(' AND '), ";\n                "),
                 params: __spreadArray(__spreadArray([], Object.values(data), true), Object.values(where), true)
             }); },
             toMSSQL: function () { return ({
-                query: "\n                    UPDATE [".concat(_this.table, "] \n                    SET ").concat(Object.keys(data).map(function (key) { return "[".concat(key, "] = @").concat(key); }).join(','), "\n                    WHERE ").concat(Object.keys(where).map(function (key) { return (0, raw_where_utils_1.converWhereQuery)('mssql', key, data[key], 'where_' + key); }).join(' AND '), ";\n                "),
+                query: "\n                    UPDATE [".concat(_this.table, "] \n                    SET ").concat(Object.keys(data).map(function (key) { return "[".concat(key, "] = @").concat(key); }).join(', '), "\n                    WHERE ").concat(Object.keys(where).map(function (key) { return (0, raw_where_utils_1.converWhereQuery)('mssql', key, data[key], 'where_' + key); }).join(' AND '), ";\n                "),
                 params: (function () {
                     var params = __assign({}, data);
                     for (var _i = 0, _a = Object.keys(where); _i < _a.length; _i++) {
@@ -44,6 +64,10 @@ var SQLEditDataCommands = /** @class */ (function () {
                     return params;
                 })()
             }); },
+            toSQLite: function () { return ({
+                query: "\n                    UPDATE \"".concat(_this.table, "\" \n                    SET ").concat(Object.keys(data).map(function (key) { return "\"".concat(key, "\" = ?"); }).join(', '), "\n                    WHERE ").concat(Object.keys(where).map(function (key) { return (0, raw_where_utils_1.converWhereQuery)('sqlite', key, where[key], '?'); }).join(' AND '), ";"),
+                params: __spreadArray(__spreadArray([], Object.values(data), true), Object.values(where), true)
+            }); },
         };
     };
     SQLEditDataCommands.prototype.upsert = function (data, idKeys) {
@@ -73,6 +97,12 @@ var SQLEditDataCommands = /** @class */ (function () {
                 query: "\n                    UPDATE [".concat(_this.table, "] \n                    SET ").concat(Object.keys(toUpdObj).map(function (key) { return "[".concat(key, "] = @").concat(key); }).join(','), "\n                    WHERE ").concat(idKeys.map(function (key) { return (0, raw_where_utils_1.converWhereQuery)('mssql', key, data[key], key); }).join(' AND '), ";\n\n                    IF @@ROWCOUNT = 0 INSERT INTO [").concat(_this.table, "]\n                        (").concat(dataKeys.map(function (a) { return "[".concat(a, "]"); }).join(', '), ")\n                        VALUES (").concat(dataKeys.map(function (key) { return '@' + key; }).join(', '), ");\n                "),
                 params: data
             }); },
+            toSQLite: function () { return ({
+                query: "\n                    INSERT INTO \"".concat(_this.table, "\" \n                    (").concat(dataKeys.map(function (key) { return "\"".concat(key, "\""); }).join(', '), ") \n                    VALUES (").concat(dataKeys.map(function () { return '?'; }).join(', '), ") \n                    ON CONFLICT (").concat(idKeys.map(function (key) { return "\"".concat(key, "\""); }).join(', '), ") \n                    DO UPDATE SET ").concat(Object.keys(toUpdObj).map(function (key) {
+                    return "\"".concat(key, "\" = excluded.\"").concat(key, "\"");
+                }).join(', '), ";"),
+                params: Object.values(data)
+            }); },
         };
     };
     return SQLEditDataCommands;

package/dist/sql/commands/select.commands.js

@@ -10,6 +10,7 @@ var SQLSelectCommands = /** @class */ (function () {
         return {
             toMySQL: function () { return "SELECT * FROM `".concat(_this.table, "`;"); },
             toMSSQL: function () { return "SELECT * FROM [".concat(_this.table, "];"); },
+            toSQLite: function () { return "SELECT * FROM \"".concat(_this.table, "\";"); },
         };
     };
     return SQLSelectCommands;

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

@@ -9,8 +9,8 @@ var SQLTablesCommands = /** @class */ (function () {
         return {
             toMySQL: function () { return "RENAME TABLE `".concat(old_name, "` TO `").concat(new_name, "`;"); },
             toMSSQL: function () { return "EXEC sp_rename '".concat(old_name, "', '").concat(new_name, "';"); },
+            toSQLite: function () { return "ALTER TABLE \"".concat(old_name, "\" RENAME TO \"").concat(new_name, "\";"); },
             // PG: ALTER TABLE "old_name" RENAME TO "new_name";
-            // SQLITE: ALTER TABLE "old_name" RENAME TO "new_name";
         };
     };
     SQLTablesCommands.tableInfo = function (database, table) {
@@ -27,6 +27,12 @@ var SQLTablesCommands = /** @class */ (function () {
                 "AND TABLE_SCHEMA = 'dbo'",
                 "AND TABLE_NAME = '".concat(table, "'"),
             ].join(' '); },
+            toSQLite: function () { return [
+                "SELECT * FROM sqlite_master",
+                "WHERE type = 'table'",
+                "AND name = '".concat(table, "'"),
+                "LIMIT 1;"
+            ].join(' '); },
         };
     };
     SQLTablesCommands.createTable = function (options) {
@@ -42,6 +48,8 @@ var SQLTablesCommands = /** @class */ (function () {
                     str += "`".concat(columnName, "` ");
                 else if (dbtype === 'mssql')
                     str += "[".concat(columnName, "] ");
+                else if (dbtype === 'sqlite')
+                    str += "\"".concat(columnName, "\" ");
                 else if (dbtype === 'postgres')
                     str += "\"".concat(columnName, "\" ");
                 else
@@ -54,12 +62,14 @@ var SQLTablesCommands = /** @class */ (function () {
         return {
             toMySQL: function () { return _createQuery('mysql'); },
             toMSSQL: function () { return _createQuery('mssql'); },
+            toSQLite: function () { return _createQuery('sqlite'); },
         };
     };
     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 * FROM (\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                ) t ORDER BY (data_kb + index_kb) DESC;\n            "; },
+            toSQLite: function () { return "\n                SELECT name AS table_name, \n                (SUM(pgsize) / 1024.0) AS data_kb \n                FROM dbstat WHERE name NOT LIKE 'sqlite_%' \n                GROUP BY name ORDER BY data_kb DESC;\n            "; },
             // postgress
             // SELECT
             //     relname AS table_name,

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

@@ -8,7 +8,7 @@ export declare abstract class AbstractSQLConnection {
     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;
+    toRawSQL(sql: ISQLCommandAdapter | SQLCommandData | string): Promise<SQLCommandData>;
     runSQL<T = any>(query: SQLCommandData): Promise<T[]>;
     runSQL<T = any>(query: ISQLCommandAdapter): Promise<T[]>;
     runSQL<T = any>(query: AbstractSQLCommand): Promise<T[]>;

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

@@ -43,6 +43,7 @@ var AbstractSQLConnection = /** @class */ (function () {
     function AbstractSQLConnection(rawOptions, abstractCommandFunctionName) {
         this.rawOptions = rawOptions;
         this.abstractCommandFunctionName = abstractCommandFunctionName;
+        this.sendSQL = this.sendSQL.bind(this);
     }
     Object.defineProperty(AbstractSQLConnection.prototype, "databaseName", {
         get: function () {
@@ -52,7 +53,17 @@ var AbstractSQLConnection = /** @class */ (function () {
         configurable: true
     });
     AbstractSQLConnection.prototype.toRawSQL = function (sql) {
-        return (0, commands_1.toRawSQL)(this.rawOptions.type, sql);
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, (0, commands_1.toRawSQL)(this.rawOptions.type, sql, {
+                            database: this.databaseName,
+                            runAdditionalSQL: this.sendSQL
+                        })];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
     };
     AbstractSQLConnection.prototype.runSQL = function (query, params) {
         var _a;
@@ -71,7 +82,8 @@ var AbstractSQLConnection = /** @class */ (function () {
                         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
+                                database: this.databaseName,
+                                runAdditionalSQL: this.sendSQL
                             }))];
                     case 1:
                         query = _b.sent();

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

@@ -8,4 +8,5 @@ export declare function createSQLConnection(options: DatabaseOptions): AbstractS
 export * from './abstract.connection';
 export * from './mysql.connection';
 export * from './mssql.connection';
+export * from './sqlite.connection';
 export { MySQLConnection as RawMySQLConnection };

package/dist/sql/connections/index.js

@@ -18,6 +18,7 @@ exports.RawMySQLConnection = exports.createSQLConnection = exports.isDatabaseTyp
 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");
+var sqlite_connection_1 = require("./sqlite.connection");
 function isDatabaseTypeIs(options, type) {
     return options.type === type;
 }
@@ -27,9 +28,12 @@ function createSQLConnection(options) {
         return new mysql_connection_1.MySQLConnection(options);
     if (isDatabaseTypeIs(options, 'mssql'))
         return new mssql_connection_1.MSSQLConnection(options);
+    if (isDatabaseTypeIs(options, 'sqlite'))
+        return new sqlite_connection_1.SQLiteConnection(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);
+__exportStar(require("./sqlite.connection"), exports);

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

@@ -0,0 +1,13 @@
+import { DatabaseOptions } from '@klapeks/utils';
+import { AbstractSQLConnection } from './abstract.connection';
+import type { Database as SQLite3Database } from 'sqlite3';
+export declare class SQLiteConnection extends AbstractSQLConnection {
+    private _db;
+    constructor(options: DatabaseOptions & {
+        type: "sqlite";
+    });
+    initConnection(): Promise<void>;
+    getConnection(): Promise<SQLite3Database>;
+    destroyConnection(): Promise<void>;
+    sendSQL<T = any>(query: string, params?: any): Promise<T[]>;
+}

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

@@ -0,0 +1,158 @@
+"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.SQLiteConnection = void 0;
+var utils_1 = require("@klapeks/utils");
+var abstract_connection_1 = require("./abstract.connection");
+var quiet_require_1 = require("../../utils/quiet.require");
+var sqlite3 = (0, quiet_require_1.quietRequire)('sqlite3');
+var logger = new utils_1.Logger('SQLite');
+var SQLiteConnection = /** @class */ (function (_super) {
+    __extends(SQLiteConnection, _super);
+    function SQLiteConnection(options) {
+        return _super.call(this, options, 'toSQLite') || this;
+    }
+    SQLiteConnection.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.getConnection()];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    SQLiteConnection.prototype.getConnection = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                if (!sqlite3)
+                    throw "sqlite3 module is not installed";
+                if (this._db)
+                    return [2 /*return*/, this._db];
+                this._db = new sqlite3.Database(this.rawOptions.database);
+                this._db.exec("\n            PRAGMA journal_mode = WAL;\n            PRAGMA busy_timeout = 15000;\n        ");
+                return [2 /*return*/, this._db];
+            });
+        });
+    };
+    SQLiteConnection.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._db)
+                            return resolve();
+                        try {
+                            _this._db.close(function (err) {
+                                logger.log('Database disconnected');
+                                if (err)
+                                    reject(err);
+                                else
+                                    resolve();
+                            });
+                        }
+                        catch (err) {
+                            reject(err);
+                        }
+                        finally {
+                            _this._db = undefined;
+                        }
+                    })];
+            });
+        });
+    };
+    SQLiteConnection.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 1:
+                        connection = _a.sent();
+                        return [2 /*return*/, new Promise(function (resolve, reject) {
+                                _this.debugQuery(query, params);
+                                var upperSQL = query.trim().toUpperCase();
+                                if (upperSQL.startsWith('BEGIN')
+                                    || upperSQL.startsWith('COMMIT')
+                                    || upperSQL.startsWith('ROLLBACK')) {
+                                    return connection.exec(query, function (err) {
+                                        if (err)
+                                            return reject(err);
+                                        resolve([]);
+                                    });
+                                }
+                                if (!params)
+                                    params = [];
+                                if (upperSQL.startsWith('SELECT') || upperSQL.startsWith("PRAGMA")) {
+                                    return connection.all(query, params, function (err1, rows) {
+                                        if (err1)
+                                            return reject(err1);
+                                        resolve((rows || []));
+                                    });
+                                }
+                                return connection.run(query, params, function (err1) {
+                                    if (err1)
+                                        return reject(err1);
+                                    resolve(this);
+                                });
+                            })];
+                }
+            });
+        });
+    };
+    return SQLiteConnection;
+}(abstract_connection_1.AbstractSQLConnection));
+exports.SQLiteConnection = SQLiteConnection;

package/dist/sql/raw.where.utils.js

@@ -7,6 +7,8 @@ function sqlQuoteKey(dbType, str) {
         return "`".concat(str, "`");
     if (dbType === 'mssql')
         return "[".concat(str, "]");
+    if (dbType === 'sqlite')
+        return "\"".concat(str, "\"");
     return str;
 }
 function converWhereQuery(dbType, key, value, keyAlias) {
@@ -24,7 +26,7 @@ function converWhereQuery(dbType, key, value, keyAlias) {
     if (value === null) {
         return sqlQuoteKey(dbType, key) + ' IS NULL';
     }
-    if (keyAlias === '?' || dbType === 'mysql') {
+    if (keyAlias === '?' || dbType === 'mysql' || dbType === 'sqlite') {
         return sqlQuoteKey(dbType, key) + " = ?";
     }
     if (dbType === 'mssql') {

package/dist/utils/columns.types.d.ts

@@ -9,14 +9,7 @@ export declare function createRelation(target: string, type: "one-to-many" | "on
     cascade: boolean;
     inverseSide: string;
 };
-export declare const MULTISQL_COLUMNS_TYPES: {
-    dbtype: "sqlite" | "mysql" | "postgres" | "mssql";
-    enum: "simple-enum" | "enum";
-    datetime: "datetime" | "datetime2" | "timestamp";
-    float32: "float" | "double";
-    float64: "float" | "double";
-    json: "simple-json" | "json";
-};
+export declare const MULTISQL_COLUMNS_TYPES: import("@klapeks/utils").IDatabaseColumnTypesList;
 export declare const FloatingColumn: MicroColumnTypeObject;
 export declare const NullableFloatingColumn: MicroColumnTypeObject;
 export declare const Float64Column: MicroColumnTypeObject;

package/dist/utils/columns.types.js

@@ -18,7 +18,7 @@ function createRelation(target, type, inverseSide, cascade) {
     return { target: target, type: type, cascade: cascade, inverseSide: inverseSide };
 }
 exports.createRelation = createRelation;
-exports.MULTISQL_COLUMNS_TYPES = (0, utils_1.getDatabaseColumnTypes)();
+exports.MULTISQL_COLUMNS_TYPES = (0, utils_1.getEnvDatabaseColumnTypes)();
 exports.FloatingColumn = {
     type: exports.MULTISQL_COLUMNS_TYPES.float32, default: 0
     // type: "decimal", precision: 10, scale: 6, default: 0

package/package.json

@@ -1,13 +1,14 @@
 {
     "name": "@klapeks/micro-db-utils",
     "description": "klapeks utils for db and other storages",
-    "version": "0.0.17",
+    "version": "0.0.20",
     "type": "commonjs",
     "author": "Klapeks",
     "license": "ISC",
     "scripts": {
         "patch": "npm version patch -f --no-git-tag-version",
         "build": "npm run patch && tsc --skipLibCheck",
+        "build:no-patch": "tsc --skipLibCheck",
         "prepublishOnly": "tsc --skipLibCheck"
     },
     "keywords": [
@@ -22,15 +23,17 @@
         "@aws-sdk/client-s3": "^3.842.0",
         "@aws-sdk/s3-request-presigner": "^3.844.0",
         "@klapeks/api-creation-tools": "^0.0.7",
-        "@klapeks/utils": "^0.1.8",
+        "@klapeks/utils": "^0.2.1",
         "@types/mssql": "^12.3.0",
         "@types/node": "^18.11.18",
+        "@types/pg": "^8.23.1",
         "axios": "^1.7.7",
         "ioredis": "^5.6.1",
         "kafkajs": "^2.2.4",
         "mongoose": "^8.16.1",
         "mssql": "^11.0.1",
         "mysql2": "^3.11.3",
+        "pg": "^8.23.0",
         "redis": "^4.7.0",
         "sqlite3": "^5.1.7",
         "typeorm": "^0.3.21",