@klapeks/micro-db-utils 0.0.1

package/dist/selectors/raw-mysql.select.handler.js

@@ -0,0 +1,149 @@
+"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.MySQLSelectEntityHandler = void 0;
+var abstract_select_handler_1 = require("./abstract.select.handler");
+var MySQLSelectEntityHandler = /** @class */ (function (_super) {
+    __extends(MySQLSelectEntityHandler, _super);
+    function MySQLSelectEntityHandler(options) {
+        return _super.call(this, options) || this;
+    }
+    MySQLSelectEntityHandler.prototype.getTableName = function () {
+        return this.options.schemaTableName;
+    };
+    MySQLSelectEntityHandler.prototype.runSQL = function (sql, params) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.options.mysql.runSQL(sql, params)];
+            });
+        });
+    };
+    MySQLSelectEntityHandler.prototype.getTotal = function () {
+        var _a;
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, this.runSQL_One("\n            SELECT count(1) as 'count'\n            FROM ".concat(this.getTableName(), ";\n        "))];
+                    case 1: return [2 /*return*/, (_a = (_b.sent())) === null || _a === void 0 ? void 0 : _a.count];
+                }
+            });
+        });
+    };
+    MySQLSelectEntityHandler.prototype.rawSelect = function (options) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function () {
+            var where, orderBy, limit, addOrderBy, i, whereCondition, result, totalCount;
+            var _this = this;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        where = [];
+                        orderBy = '';
+                        limit = '';
+                        // if (options.where) {
+                        //     const W = options.where as any;
+                        //     for (let key of Object.keys(W)) {
+                        //         if (typeof W[key] == 'undefined' || W[key] === null) continue;
+                        //         where.push([key, W[key]]);
+                        //     }
+                        // }
+                        if (this.options.orderBy) {
+                            orderBy = 'ORDER BY ';
+                            addOrderBy = function (field, _index) {
+                                if (_index === void 0) { _index = 0; }
+                                var orderType = 'ASC';
+                                if (Array.isArray(_this.options.orderType)) {
+                                    orderType = _this.options.orderType[_index] || _this.options.orderType[0];
+                                }
+                                else {
+                                    orderType = _this.options.orderType || 'ASC';
+                                }
+                                orderBy += field + ' ' + orderType.toUpperCase();
+                            };
+                            if (Array.isArray(this.options.orderBy)) {
+                                for (i = 0; i < this.options.orderBy.length; i++) {
+                                    if (i)
+                                        orderBy += ', ';
+                                    addOrderBy(this.options.orderBy[i], i);
+                                }
+                            }
+                            else {
+                                addOrderBy(this.options.orderBy, 0);
+                            }
+                        }
+                        if (options.limit) {
+                            limit = 'LIMIT ' + options.limit;
+                            if (options.offset) {
+                                limit += ' OFFSET ' + options.offset;
+                            }
+                        }
+                        whereCondition = (where === null || where === void 0 ? void 0 : where.length) ? ('WHERE ' + where.map(function (w) { return w[0] + ' = ?'; }).join(' AND ')) : '';
+                        return [4 /*yield*/, this.runSQL("\n            SELECT * FROM ".concat(this.getTableName(), "\n            ").concat(whereCondition, " ").concat(orderBy, " ").concat(limit, "\n        "), where.map(function (d) { return d[1]; }))];
+                    case 1:
+                        result = _b.sent();
+                        return [4 /*yield*/, this.runSQL("\n            SELECT count(1) as 'count' \n            FROM ".concat(this.getTableName(), "\n            ").concat(whereCondition, "\n        "), where.map(function (d) { return d[1]; }))];
+                    case 2:
+                        totalCount = _b.sent();
+                        if (!this.options.afterSelect) return [3 /*break*/, 4];
+                        return [4 /*yield*/, this.options.afterSelect(result, options)];
+                    case 3:
+                        result = _b.sent();
+                        _b.label = 4;
+                    case 4: return [2 /*return*/, { objects: result, total: ((_a = totalCount === null || totalCount === void 0 ? void 0 : totalCount[0]) === null || _a === void 0 ? void 0 : _a.count) || NaN }];
+                }
+            });
+        });
+    };
+    return MySQLSelectEntityHandler;
+}(abstract_select_handler_1.AbstractSelectHandler));
+exports.MySQLSelectEntityHandler = MySQLSelectEntityHandler;

package/dist/selectors/typeorm.select.handler.d.ts

@@ -0,0 +1,21 @@
+import { DataSource, EntitySchema, ObjectLiteral, SelectQueryBuilder } from 'typeorm';
+import { AbstractSelectHandler, SelectEntityHandlerOptions } from './abstract.select.handler';
+import { SelectOptions } from '@klapeks/api-creation-tools';
+export type TypeormSelectEntityHandlerOptions<T extends ObjectLiteral, K extends string> = SelectEntityHandlerOptions<T, K> & {
+    schema: EntitySchema<T>;
+    dataSource: DataSource;
+    beforeGetMany?: (builder: SelectQueryBuilder<T>, options: SelectOptions<T>) => Promise<void> | void;
+};
+export declare class SelectEntityHandler<T extends ObjectLiteral, K extends string> extends AbstractSelectHandler<T, K, TypeormSelectEntityHandlerOptions<T, K>> {
+    constructor(options: TypeormSelectEntityHandlerOptions<T, K>);
+    get dataSource(): DataSource;
+    get schema(): EntitySchema<T>;
+    get repo(): import("typeorm").Repository<T>;
+    getTableName(): string;
+    runSQL(sql: string, params?: any[]): Promise<any[]>;
+    getTotal(): Promise<number>;
+    rawSelect(options: SelectOptions<T>): Promise<{
+        objects: T[];
+        total: number;
+    }>;
+}

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

@@ -0,0 +1,187 @@
+"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.SelectEntityHandler = void 0;
+var typeorm_1 = require("typeorm");
+var abstract_select_handler_1 = require("./abstract.select.handler");
+var SelectEntityHandler = /** @class */ (function (_super) {
+    __extends(SelectEntityHandler, _super);
+    function SelectEntityHandler(options) {
+        return _super.call(this, options) || this;
+    }
+    Object.defineProperty(SelectEntityHandler.prototype, "dataSource", {
+        get: function () { return this.options.dataSource; },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(SelectEntityHandler.prototype, "schema", {
+        get: function () { return this.options.schema; },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(SelectEntityHandler.prototype, "repo", {
+        get: function () { return this.dataSource.getRepository(this.schema); },
+        enumerable: false,
+        configurable: true
+    });
+    SelectEntityHandler.prototype.getTableName = function () {
+        return this.schema.options.name;
+    };
+    SelectEntityHandler.prototype.runSQL = function (sql, params) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.dataSource.query(sql, params)];
+            });
+        });
+    };
+    SelectEntityHandler.prototype.getTotal = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.repo.count()];
+            });
+        });
+    };
+    SelectEntityHandler.prototype.rawSelect = function (options) {
+        return __awaiter(this, void 0, void 0, function () {
+            var builder, addOrderBy, i, multipleWheres_1, result;
+            var _a;
+            var _this = this;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        builder = this.repo.createQueryBuilder(this.schema.options.name);
+                        builder.select(this.schema.options.name + '.*');
+                        // if (this.options.preBuilder) this.options.preBuilder(builder);
+                        if (this.options.orderBy) {
+                            addOrderBy = function (field, _index) {
+                                if (_index === void 0) { _index = 0; }
+                                var orderType = 'ASC';
+                                if (Array.isArray(_this.options.orderType)) {
+                                    orderType = _this.options.orderType[_index] || _this.options.orderType[0];
+                                }
+                                else {
+                                    orderType = _this.options.orderType || 'ASC';
+                                }
+                                if (_index)
+                                    builder.addOrderBy(field, orderType.toUpperCase());
+                                else
+                                    builder.orderBy(field, orderType.toUpperCase());
+                            };
+                            if (Array.isArray(this.options.orderBy)) {
+                                for (i = 0; i < this.options.orderBy.length; i++) {
+                                    addOrderBy(this.options.orderBy[i], i);
+                                }
+                            }
+                            else {
+                                addOrderBy(this.options.orderBy, 0);
+                            }
+                        }
+                        if (options.where) {
+                            multipleWheres_1 = Array.isArray(options.where) ? options.where : [options.where];
+                            builder.andWhere(new typeorm_1.Brackets(function (qb1) {
+                                var _loop_1 = function (i) {
+                                    var where = multipleWheres_1[i];
+                                    qb1 = qb1.orWhere(new typeorm_1.Brackets(function (qb2) {
+                                        var _a, _b;
+                                        for (var _i = 0, _c = Object.keys(where); _i < _c.length; _i++) {
+                                            var key = _c[_i];
+                                            var placeholderKey = key + "_" + i;
+                                            if (typeof where[key] == undefined)
+                                                continue;
+                                            if (where[key] == null) {
+                                                qb2 = qb2.andWhere('key is NULL');
+                                                continue;
+                                            }
+                                            if (typeof where[key] == 'string' && where[key].startsWith('{like}=')) {
+                                                var strVal = where[key].substring(7).toLowerCase();
+                                                qb2 = qb2.andWhere('lower(' + key + ') like :' + placeholderKey, (_a = {}, _a[placeholderKey] = strVal, _a));
+                                                continue;
+                                            }
+                                            qb2 = qb2.andWhere(key + ' = :' + placeholderKey, (_b = {}, _b[placeholderKey] = where[key], _b));
+                                        }
+                                    }));
+                                };
+                                // qb1 = qb1.where('0 = 1');
+                                for (var i = 0; i < multipleWheres_1.length; i++) {
+                                    _loop_1(i);
+                                }
+                            }));
+                        }
+                        if (!this.options.beforeGetMany) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.options.beforeGetMany(builder, options)];
+                    case 1:
+                        _b.sent();
+                        _b.label = 2;
+                    case 2:
+                        builder.limit(options.limit);
+                        if (options.offset)
+                            builder.offset(options.offset);
+                        return [4 /*yield*/, builder.getRawMany()];
+                    case 3:
+                        result = _b.sent();
+                        if (!this.options.afterSelect) return [3 /*break*/, 5];
+                        return [4 /*yield*/, this.options.afterSelect(result, options)];
+                    case 4:
+                        result = _b.sent();
+                        _b.label = 5;
+                    case 5:
+                        _a = { objects: result };
+                        return [4 /*yield*/, builder.getCount()];
+                    case 6: return [2 /*return*/, (_a.total = _b.sent(), _a)];
+                }
+            });
+        });
+    };
+    return SelectEntityHandler;
+}(abstract_select_handler_1.AbstractSelectHandler));
+exports.SelectEntityHandler = SelectEntityHandler;

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

@@ -0,0 +1,100 @@
+import mongoose from "mongoose";
+import { EntitySchemaColumnOptions, EntitySchemaOptions } from "typeorm";
+export type RequiredColumns<T> = Required<EntitySchemaOptions<T>['columns']>;
+export type RequiredMongoColumns<T> = Required<mongoose.Schema<T>>;
+export declare function createRelation(target: string, type: "one-to-many" | "one-to-one", inverseSide: string, cascade?: boolean): {
+    target: string;
+    type: "one-to-many" | "one-to-one";
+    cascade: boolean;
+    inverseSide: string;
+};
+export declare const FloatingColumn: EntitySchemaColumnOptions;
+export declare const NullableFloatingColumn: {
+    default: null;
+    nullable: boolean;
+    primary?: boolean | undefined;
+    objectId?: boolean | undefined;
+    createDate?: boolean | undefined;
+    updateDate?: boolean | undefined;
+    deleteDate?: boolean | undefined;
+    version?: boolean | undefined;
+    treeChildrenCount?: boolean | undefined;
+    treeLevel?: boolean | undefined;
+    virtualProperty?: boolean | undefined;
+    type: import("typeorm").ColumnType;
+    name?: string | undefined;
+    length?: string | number | undefined;
+    width?: number | undefined;
+    readonly?: boolean | undefined;
+    update?: boolean | undefined;
+    select?: boolean | undefined;
+    insert?: boolean | undefined;
+    generated?: true | "uuid" | "increment" | "rowid" | undefined;
+    unique?: boolean | undefined;
+    columnDefinition?: string | undefined;
+    comment?: string | undefined;
+    onUpdate?: string | undefined;
+    precision?: number | undefined;
+    scale?: number | undefined;
+    zerofill?: boolean | undefined;
+    unsigned?: boolean | undefined;
+    charset?: string | undefined;
+    collation?: string | undefined;
+    enum?: Object | any[] | undefined;
+    enumName?: string | undefined;
+    asExpression?: string | undefined;
+    generatedType?: "VIRTUAL" | "STORED" | undefined;
+    hstoreType?: "string" | "object" | undefined;
+    array?: boolean | undefined;
+    transformer?: import("typeorm").ValueTransformer | import("typeorm").ValueTransformer[] | undefined;
+    primaryKeyConstraintName?: string | undefined;
+    foreignKey?: import("typeorm/entity-schema/EntitySchemaColumnForeignKeyOptions").EntitySchemaColumnForeignKeyOptions | undefined;
+    query?: ((alias: string) => string) | undefined;
+    spatialFeatureType?: "Point" | "LineString" | "Polygon" | "MultiPoint" | "MultiLineString" | "MultiPolygon" | "GeometryCollection" | undefined;
+    srid?: number | undefined;
+};
+export declare const Float64Column: EntitySchemaColumnOptions;
+export declare const NullableFloat64Column: {
+    default: null;
+    nullable: boolean;
+    primary?: boolean | undefined;
+    objectId?: boolean | undefined;
+    createDate?: boolean | undefined;
+    updateDate?: boolean | undefined;
+    deleteDate?: boolean | undefined;
+    version?: boolean | undefined;
+    treeChildrenCount?: boolean | undefined;
+    treeLevel?: boolean | undefined;
+    virtualProperty?: boolean | undefined;
+    type: import("typeorm").ColumnType;
+    name?: string | undefined;
+    length?: string | number | undefined;
+    width?: number | undefined;
+    readonly?: boolean | undefined;
+    update?: boolean | undefined;
+    select?: boolean | undefined;
+    insert?: boolean | undefined;
+    generated?: true | "uuid" | "increment" | "rowid" | undefined;
+    unique?: boolean | undefined;
+    columnDefinition?: string | undefined;
+    comment?: string | undefined;
+    onUpdate?: string | undefined;
+    precision?: number | undefined;
+    scale?: number | undefined;
+    zerofill?: boolean | undefined;
+    unsigned?: boolean | undefined;
+    charset?: string | undefined;
+    collation?: string | undefined;
+    enum?: Object | any[] | undefined;
+    enumName?: string | undefined;
+    asExpression?: string | undefined;
+    generatedType?: "VIRTUAL" | "STORED" | undefined;
+    hstoreType?: "string" | "object" | undefined;
+    array?: boolean | undefined;
+    transformer?: import("typeorm").ValueTransformer | import("typeorm").ValueTransformer[] | undefined;
+    primaryKeyConstraintName?: string | undefined;
+    foreignKey?: import("typeorm/entity-schema/EntitySchemaColumnForeignKeyOptions").EntitySchemaColumnForeignKeyOptions | undefined;
+    query?: ((alias: string) => string) | undefined;
+    spatialFeatureType?: "Point" | "LineString" | "Polygon" | "MultiPoint" | "MultiLineString" | "MultiPolygon" | "GeometryCollection" | undefined;
+    srid?: number | undefined;
+};

package/dist/utils/columns.types.js

@@ -0,0 +1,29 @@
+"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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NullableFloat64Column = exports.Float64Column = exports.NullableFloatingColumn = exports.FloatingColumn = exports.createRelation = void 0;
+function createRelation(target, type, inverseSide, cascade) {
+    if (cascade === void 0) { cascade = true; }
+    return { target: target, type: type, cascade: cascade, inverseSide: inverseSide };
+}
+exports.createRelation = createRelation;
+exports.FloatingColumn = {
+    type: "float", default: 0
+    // type: "decimal", precision: 10, scale: 6, default: 0
+};
+exports.NullableFloatingColumn = __assign(__assign({}, exports.FloatingColumn), { default: null, nullable: true });
+exports.Float64Column = {
+    type: "double", default: 0
+    // type: "decimal", precision: 10, scale: 6, default: 0
+};
+exports.NullableFloat64Column = __assign(__assign({}, exports.Float64Column), { default: null, nullable: true });

package/dist/utils/index.d.ts

@@ -0,0 +1,3 @@
+export * from './columns.types';
+export * from './sqlite3.utils';
+export * from './where.utils';

package/dist/utils/index.js

@@ -0,0 +1,21 @@
+"use strict";
+// LOCAL, DON'T EXPORT
+// export * from './iso.date.time';
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./columns.types"), exports);
+__exportStar(require("./sqlite3.utils"), exports);
+__exportStar(require("./where.utils"), exports);

package/dist/utils/iso.date.time.d.ts

@@ -0,0 +1,2 @@
+export declare function toISODate(date: Date, type?: 'yyyy-mm-dd' | "full"): string;
+export declare function dateFromNow(func: (date: Date) => void, date?: Date): Date;

package/dist/utils/iso.date.time.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dateFromNow = exports.toISODate = void 0;
+var pad2 = function (p) {
+    return p.toString().padStart(2, '0');
+};
+function toISODate(date, type) {
+    if (type === 'yyyy-mm-dd') {
+        return date.getFullYear()
+            + '-' + pad2(date.getMonth() + 1)
+            + '-' + pad2(date.getDate());
+    }
+    return date.getFullYear()
+        + '-' + pad2(date.getMonth() + 1)
+        + '-' + pad2(date.getDate())
+        + ' ' + pad2(date.getHours())
+        + ':' + pad2(date.getMinutes())
+        + ':' + pad2(date.getSeconds());
+}
+exports.toISODate = toISODate;
+function dateFromNow(func, date) {
+    if (!date)
+        date = new Date();
+    func(date);
+    return date;
+}
+exports.dateFromNow = dateFromNow;

package/dist/utils/sqlite3.utils.d.ts

@@ -0,0 +1,4 @@
+import type { Database } from "sqlite3";
+export declare const sqlite3_utils: (db: Database) => {
+    all: <T>(query: string) => Promise<T[]>;
+};

package/dist/utils/sqlite3.utils.js

@@ -0,0 +1,60 @@
+"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.sqlite3_utils = void 0;
+var sqlite3_utils = function (db) {
+    function all(query) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, new Promise(function (resolve, reject) {
+                            db.all(query, function (err, data) {
+                                if (err)
+                                    reject(err);
+                                else
+                                    resolve(data);
+                            });
+                        })];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    }
+    return { all: all };
+};
+exports.sqlite3_utils = sqlite3_utils;

package/dist/utils/where.utils.d.ts

@@ -0,0 +1,3 @@
+import { ObjectLiteral, SelectQueryBuilder } from "typeorm";
+export declare function addTimedWhere<T extends ObjectLiteral>(builder: SelectQueryBuilder<T>, dateAlias: string, from: Date, to?: Date): SelectQueryBuilder<T>;
+export declare function rawTimedWhere(dateAlias: string, from: Date, to?: Date): string;

package/dist/utils/where.utils.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rawTimedWhere = exports.addTimedWhere = void 0;
+var iso_date_time_1 = require("./iso.date.time");
+function addTimedWhere(builder, dateAlias, from, to) {
+    builder.where("date(" + dateAlias + ") >= date(:from)", {
+        from: (0, iso_date_time_1.toISODate)(from, "yyyy-mm-dd")
+    });
+    if (to)
+        builder.andWhere("date(" + dateAlias + ") <= date(:to)", {
+            to: (0, iso_date_time_1.toISODate)(to, "yyyy-mm-dd")
+        });
+    return builder;
+}
+exports.addTimedWhere = addTimedWhere;
+function rawTimedWhere(dateAlias, from, to) {
+    var sql = "date(" + dateAlias + ") >= date('" + (0, iso_date_time_1.toISODate)(from, "yyyy-mm-dd") + "') ";
+    if (to)
+        sql += "AND date(" + dateAlias + ") <= date('" + (0, iso_date_time_1.toISODate)(to, "yyyy-mm-dd") + "')";
+    return sql;
+}
+exports.rawTimedWhere = rawTimedWhere;

package/index.d.ts

@@ -0,0 +1 @@
+export * from './dist/index.d';

package/index.js

@@ -0,0 +1,2 @@
+'use strict';
+module.exports = require('./dist/index');