@klapeks/micro-db-utils 0.0.16 → 0.0.18

package/dist/selectors/abstract.select.handler.js

@@ -97,13 +97,13 @@ var AbstractSelectHandler = /** @class */ (function () {
         });
     };
     AbstractSelectHandler.prototype.getSumStatistic = function (sumField, strWhere) {
-        var _a;
+        var _a, _b;
         return __awaiter(this, void 0, void 0, function () {
-            var stat, time, response, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o;
-            var _p, _q;
+            var stat, time, response, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p;
+            var _q, _r;
             var _this = this;
-            return __generator(this, function (_r) {
-                switch (_r.label) {
+            return __generator(this, function (_s) {
+                switch (_s.label) {
                     case 0:
                         stat = function (fromDate, time) { return __awaiter(_this, void 0, void 0, function () {
                             var expr, isoDate, sum;
@@ -128,65 +128,65 @@ var AbstractSelectHandler = /** @class */ (function () {
                             });
                         }); };
                         time = new Date().toLocaleTimeString('uk-UA');
-                        _p = {
+                        _q = {
                             serverTime: time
                         };
-                        return [4 /*yield*/, this.getTotal()];
+                        return [4 /*yield*/, this.runSQL_One("\n                SELECT COUNT(1) AS count\n                FROM ".concat(this.getTableName(), " \n                ").concat(strWhere ? ("WHERE " + strWhere) : '', "\n            "))];
                     case 1:
-                        response = (_p.count = _r.sent(),
-                            _p);
-                        _b = response;
-                        _q = {
+                        response = (_q.count = (_a = (_s.sent())) === null || _a === void 0 ? void 0 : _a.count,
+                            _q);
+                        _c = response;
+                        _r = {
                             from: new Date(0)
                         };
-                        return [4 /*yield*/, this.runSQL_One("\n                SELECT SUM(".concat(sumField, ") as sum\n                FROM ").concat(this.getTableName(), "\n                ").concat(strWhere ? ("WHERE " + strWhere) : '', "\n            "))];
+                        return [4 /*yield*/, this.runSQL_One("\n                SELECT SUM(".concat(sumField, ") AS sum\n                FROM ").concat(this.getTableName(), "\n                ").concat(strWhere ? ("WHERE " + strWhere) : '', "\n            "))];
                     case 2:
-                        _b.total = (_q.sum = (_a = (_r.sent())) === null || _a === void 0 ? void 0 : _a.sum,
-                            _q);
-                        _c = response;
+                        _c.total = (_r.sum = (_b = (_s.sent())) === null || _b === void 0 ? void 0 : _b.sum,
+                            _r);
+                        _d = response;
                         return [4 /*yield*/, stat(new Date())];
                     case 3:
-                        _c.thisDay = _r.sent();
-                        _d = response;
+                        _d.thisDay = _s.sent();
+                        _e = response;
                         return [4 /*yield*/, stat(function (d) { return d.setDate(d.getDate() - (d.getDay() || 7) + 1); })];
                     case 4:
-                        _d.thisWeek = _r.sent();
-                        _e = response;
+                        _e.thisWeek = _s.sent();
+                        _f = response;
                         return [4 /*yield*/, stat(function (d) { return d.setDate(1); })];
                     case 5:
-                        _e.thisMonth = _r.sent();
-                        _f = response;
+                        _f.thisMonth = _s.sent();
+                        _g = response;
                         return [4 /*yield*/, stat(function (d) { d.setMonth(0); d.setDate(1); })];
                     case 6:
-                        _f.thisYear = _r.sent();
-                        _g = response;
+                        _g.thisYear = _s.sent();
+                        _h = response;
                         return [4 /*yield*/, stat(function (d) { return d.setDate(d.getDate() - 1); }, time)];
                     case 7:
-                        _g.past24hours = _r.sent();
-                        _h = response;
+                        _h.past24hours = _s.sent();
+                        _j = response;
                         return [4 /*yield*/, stat(function (d) { return d.setDate(d.getDate() - 2); })];
                     case 8:
-                        _h.past3days = _r.sent();
-                        _j = response;
+                        _j.past3days = _s.sent();
+                        _k = response;
                         return [4 /*yield*/, stat(function (d) { return d.setDate(d.getDate() - 6); })];
                     case 9:
-                        _j.past7days = _r.sent();
-                        _k = response;
+                        _k.past7days = _s.sent();
+                        _l = response;
                         return [4 /*yield*/, stat(function (d) { return d.setDate(d.getDate() - 13); })];
                     case 10:
-                        _k.past14days = _r.sent();
-                        _l = response;
+                        _l.past14days = _s.sent();
+                        _m = response;
                         return [4 /*yield*/, stat(function (d) { return d.setDate(d.getDate() - 29); })];
                     case 11:
-                        _l.past30days = _r.sent();
-                        _m = response;
+                        _m.past30days = _s.sent();
+                        _o = response;
                         return [4 /*yield*/, stat(function (d) { return d.setMonth(d.getMonth() - 6); })];
                     case 12:
-                        _m.past6months = _r.sent();
-                        _o = response;
+                        _o.past6months = _s.sent();
+                        _p = response;
                         return [4 /*yield*/, stat(function (d) { return d.setMonth(d.getMonth() - 12); })];
                     case 13:
-                        _o.past12months = _r.sent();
+                        _p.past12months = _s.sent();
                         return [2 /*return*/, response];
                 }
             });

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

@@ -8,14 +8,17 @@ export interface SQLCommandContext {
 export interface ISQLCommandAdapter {
     toMySQL(ctx?: SQLCommandContext): SQLCommandData | string;
     toMSSQL(ctx?: SQLCommandContext): SQLCommandData | string;
+    toSQLite(ctx?: SQLCommandContext): SQLCommandData | string;
 }
 export declare abstract class AbstractSQLCommand implements ISQLCommandAdapter {
     abstract toMySQL(ctx?: SQLCommandContext): SQLCommandData | string;
     abstract toMSSQL(ctx?: SQLCommandContext): SQLCommandData | string;
+    abstract toSQLite(ctx?: SQLCommandContext): SQLCommandData | 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;

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

@@ -11,6 +11,7 @@ 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;
@@ -22,6 +23,8 @@ function toRawSQL(dbType, query) {
             query = query.toMySQL({});
         else if (dbType === 'mssql')
             query = query.toMSSQL({});
+        else if (dbType === 'sqlite')
+            query = query.toSQLite({});
         else
             throw "Unknown database type: " + dbType;
     }

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

@@ -13,25 +13,29 @@ 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 () { throw "Not implemented yet: changeColumnType for sqlite :("; },
         };
     };
     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/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')) {
+                                    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

@@ -11,7 +11,11 @@ export declare function createRelation(target: string, type: "one-to-many" | "on
 };
 export declare const MULTISQL_COLUMNS_TYPES: {
     dbtype: "sqlite" | "mysql" | "postgres" | "mssql";
+    int32: "int" | "integer";
+    string: "character varying" | "nvarchar" | "varchar" | "text";
+    boolean: "boolean" | "tinyint" | "integer" | "bit";
     enum: "simple-enum" | "enum";
+    bigint: "bigint" | "integer";
     datetime: "datetime" | "datetime2" | "timestamp";
     float32: "float" | "double";
     float64: "float" | "double";

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@klapeks/micro-db-utils",
     "description": "klapeks utils for db and other storages",
-    "version": "0.0.16",
+    "version": "0.0.18",
     "type": "commonjs",
     "author": "Klapeks",
     "license": "ISC",
@@ -22,15 +22,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.1.9",
         "@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",