@oino-ts/db 0.0.11

package/dist/cjs/OINODbRequestParams.js

@@ -0,0 +1,280 @@
+"use strict";
+/*
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OINODbSqlLimit = exports.OINODbSqlOrder = exports.OINODbSqlFilter = exports.OINODbSqlComparison = exports.OINODbSqlBooleanOperation = void 0;
+const index_js_1 = require("./index.js");
+/**
+ * Supported logical conjunctions in filter predicates.
+ * @enum
+ */
+var OINODbSqlBooleanOperation;
+(function (OINODbSqlBooleanOperation) {
+    OINODbSqlBooleanOperation["and"] = "and";
+    OINODbSqlBooleanOperation["or"] = "or";
+    OINODbSqlBooleanOperation["not"] = "not";
+})(OINODbSqlBooleanOperation || (exports.OINODbSqlBooleanOperation = OINODbSqlBooleanOperation = {}));
+/**
+ * Supported logical conjunctions in filter predicates.
+ * @enum
+ */
+var OINODbSqlComparison;
+(function (OINODbSqlComparison) {
+    OINODbSqlComparison["lt"] = "lt";
+    OINODbSqlComparison["le"] = "le";
+    OINODbSqlComparison["eq"] = "eq";
+    OINODbSqlComparison["ge"] = "ge";
+    OINODbSqlComparison["gt"] = "gt";
+    OINODbSqlComparison["like"] = "like";
+})(OINODbSqlComparison || (exports.OINODbSqlComparison = OINODbSqlComparison = {}));
+/**
+ * Class for recursively parsing of filters and printing them as SQL conditions.
+ * Supports three types of statements
+ * - comparison: (field)-lt|le|eq|ge|gt|like(value)
+ * - negation: -not(filter)
+ * - conjunction/disjunction: (filter)-and|or(filter)
+ * Supported conditions are comparisons (<, <=, =, >=, >) and substring match (LIKE).
+ *
+ */
+class OINODbSqlFilter {
+    static _booleanOperationRegex = /^\s?\-(and|or)\s?$/i;
+    static _negationRegex = /^-(not|)\((.+)\)$/i;
+    static _filterComparisonRegex = /^\(([^'"\(\)]+)\)\s?\-(lt|le|eq|ge|gt|like)\s?\(([^'"\(\)]+)\)$/i;
+    _leftSide;
+    _rightSide;
+    _operator;
+    /**
+     * Constructor of `OINODbSqlFilter`
+     * @param leftSide left side of the filter, either another filter or a column name
+     * @param operation operation of the filter, either `OINODbSqlComparison` or `OINODbSqlBooleanOperation`
+     * @param rightSide right side of the filter, either another filter or a value
+     */
+    constructor(leftSide, operation, rightSide) {
+        if (!(((operation === null) && (leftSide == "") && (rightSide == "")) ||
+            ((operation !== null) && (Object.values(OINODbSqlComparison).includes(operation)) && (typeof (leftSide) == "string") && (leftSide != "") && (typeof (rightSide) == "string") && (rightSide != "")) ||
+            ((operation == OINODbSqlBooleanOperation.not) && (leftSide == "") && (rightSide instanceof OINODbSqlFilter)) ||
+            (((operation == OINODbSqlBooleanOperation.and) || (operation == OINODbSqlBooleanOperation.or)) && (leftSide instanceof OINODbSqlFilter) && (rightSide instanceof OINODbSqlFilter)))) {
+            index_js_1.OINOLog.debug("Unsupported OINODbSqlFilter format!", { leftSide: leftSide, operation: operation, rightSide: rightSide });
+            throw new Error(index_js_1.OINO_ERROR_PREFIX + ": Unsupported OINODbSqlFilter format!");
+        }
+        this._leftSide = leftSide;
+        this._operator = operation;
+        this._rightSide = rightSide;
+    }
+    /**
+     * Constructor for `OINOFilter` as parser of http parameter.
+     *
+     * @param filterString string representation of filter from HTTP-request
+     *
+     */
+    static parse(filterString) {
+        // OINOLog_debug("OINOFilter.constructor", {filterString:filterString})
+        if (!filterString) {
+            return new OINODbSqlFilter("", null, "");
+        }
+        else {
+            let match = OINODbSqlFilter._filterComparisonRegex.exec(filterString);
+            if (match != null) {
+                return new OINODbSqlFilter(match[1], match[2].toLowerCase(), match[3]);
+            }
+            else {
+                let match = OINODbSqlFilter._negationRegex.exec(filterString);
+                if (match != null) {
+                    return new OINODbSqlFilter("", OINODbSqlBooleanOperation.not, OINODbSqlFilter.parse(match[3]));
+                }
+                else {
+                    let boolean_parts = index_js_1.OINOStr.splitByBrackets(filterString, true, false, '(', ')');
+                    // OINOLog_debug("OINOFilter.constructor", {boolean_parts:boolean_parts})
+                    if (boolean_parts.length == 3 && (boolean_parts[1].match(OINODbSqlFilter._booleanOperationRegex))) {
+                        return new OINODbSqlFilter(OINODbSqlFilter.parse(boolean_parts[0]), boolean_parts[1].trim().toLowerCase().substring(1), OINODbSqlFilter.parse(boolean_parts[2]));
+                    }
+                    else {
+                        throw new Error(index_js_1.OINO_ERROR_PREFIX + ": Invalid filter '" + filterString + "'");
+                    }
+                }
+            }
+        }
+    }
+    /**
+     * Construct a new `OINOFilter` as combination of (boolean and/or) of two filters.
+     *
+     * @param leftSide left side to combine
+     * @param operation boolean operation to use in combination
+     * @param rightSide right side to combine
+     *
+     */
+    static combine(leftSide, operation, rightSide) {
+        if ((leftSide) && (!leftSide.isEmpty()) && (rightSide) && (!rightSide.isEmpty())) {
+            return new OINODbSqlFilter(leftSide, operation, rightSide);
+        }
+        else if ((leftSide) && (!leftSide.isEmpty())) {
+            return leftSide;
+        }
+        else if ((rightSide) && (!rightSide.isEmpty())) {
+            return rightSide;
+        }
+        else {
+            return undefined;
+        }
+    }
+    _operatorToSql() {
+        switch (this._operator) {
+            case "and": return " AND ";
+            case "or": return " OR ";
+            case "not": return "NOT ";
+            case "lt": return " < ";
+            case "le": return " <= ";
+            case "eq": return " = ";
+            case "ge": return " >= ";
+            case "gt": return " > ";
+            case "like": return " LIKE ";
+        }
+        return " ";
+    }
+    /**
+     * Does filter contain any valid conditions.
+     *
+     */
+    isEmpty() {
+        return (this._leftSide == "") && (this._operator == null) && (this._rightSide == "");
+    }
+    /**
+     * Print filter as SQL condition based on the datamodel of the API.
+     *
+     * @param dataModel data model (and database) to use for formatting of values
+     *
+     */
+    toSql(dataModel) {
+        // OINOLog.debug("OINOFilter.toSql", {_leftSide:this._leftSide, _operator:this._operator, _rightSide:this._rightSide})
+        if (this.isEmpty()) {
+            return "";
+        }
+        let result = "";
+        let field = null;
+        if (this._leftSide instanceof OINODbSqlFilter) {
+            result += this._leftSide.toSql(dataModel);
+        }
+        else {
+            result += dataModel.api.db.printSqlColumnname(this._leftSide);
+            field = dataModel.findFieldByName(this._leftSide);
+        }
+        result += this._operatorToSql();
+        if (this._rightSide instanceof OINODbSqlFilter) {
+            result += this._rightSide.toSql(dataModel);
+        }
+        else {
+            if (field) {
+                result += field.printCellAsSqlValue(this._rightSide);
+            }
+            else {
+                result += this._rightSide;
+            }
+        }
+        index_js_1.OINOLog.debug("OINOFilter.toSql", { result: result });
+        return "(" + result + ")";
+    }
+}
+exports.OINODbSqlFilter = OINODbSqlFilter;
+/**
+ * Class for ordering select results on a number of columns.
+ *
+ */
+class OINODbSqlOrder {
+    static _orderColumnRegex = /^\s*(\w+)\s?(ASC|DESC)?\s*?$/i;
+    _columns;
+    _directions;
+    /**
+     * Constructor for `OINODbSqlOrder`.
+     *
+     * @param orderString string representation of filter from HTTP-request
+     *
+     */
+    constructor(orderString) {
+        // OINOLog.debug("OINODbSqlOrder.constructor", {orderString:orderString})
+        this._columns = [];
+        this._directions = [];
+        const column_strings = orderString.split(',');
+        for (let i = 0; i < column_strings.length; i++) {
+            let match = OINODbSqlOrder._orderColumnRegex.exec(column_strings[i]);
+            if (match != null) {
+                this._columns.push(match[1]);
+                this._directions.push((match[2] || "ASC").toUpperCase());
+            }
+        }
+        // OINOLog.debug("OINODbSqlOrder.constructor", {columns:this._columns, directions:this._directions})
+    }
+    /**
+     * Does filter contain any valid conditions.
+     *
+     */
+    isEmpty() {
+        return (this._columns.length == 0);
+    }
+    /**
+     * Print order as SQL condition based on the datamodel of the API.
+     *
+     * @param dataModel data model (and database) to use for formatting of values
+     *
+     */
+    toSql(dataModel) {
+        if (this.isEmpty()) {
+            return "";
+        }
+        // OINOLog.debug("OINODbSqlOrder.toSql", {columns:this._columns, directions:this._directions})
+        let result = "";
+        for (let i = 0; i < this._columns.length; i++) {
+            const field = dataModel.findFieldByName(this._columns[i]);
+            if (field) {
+                if (result) {
+                    result += ",";
+                }
+                result += dataModel.api.db.printSqlColumnname(field.name) + " " + this._directions[i];
+            }
+        }
+        // OINOLog.debug("OINODbSqlOrder.toSql", {result:result})
+        return result;
+    }
+}
+exports.OINODbSqlOrder = OINODbSqlOrder;
+/**
+ * Class for limiting the number of results.
+ *
+ */
+class OINODbSqlLimit {
+    static _orderColumnRegex = /^(\d+)?$/i;
+    _limit;
+    /**
+     * Constructor for `OINODbSqlLimit`.
+     *
+     * @param limitString string representation of filter from HTTP-request
+     *
+     */
+    constructor(limitString) {
+        this._limit = 0;
+        this._limit = Number.parseInt(limitString);
+    }
+    /**
+     * Does filter contain any valid conditions.
+     *
+     */
+    isEmpty() {
+        return (this._limit <= 0);
+    }
+    /**
+     * Print order as SQL condition based on the datamodel of the API.
+     *
+     * @param dataModel data model (and database) to use for formatting of values
+     *
+     */
+    toSql(dataModel) {
+        if (this.isEmpty()) {
+            return "";
+        }
+        let result = this._limit.toString();
+        return result;
+    }
+}
+exports.OINODbSqlLimit = OINODbSqlLimit;

package/dist/cjs/OINODbSwagger.js

@@ -0,0 +1,201 @@
+"use strict";
+/*
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OINODbSwagger = void 0;
+/**
+ * Static class for Swagger utilities
+ *
+ */
+class OINODbSwagger {
+    static _getSchemaApiMethodParamsQueryId() {
+        return {
+            "schema": {
+                "type": "string"
+            },
+            "in": "path",
+            "name": "id",
+            "required": true
+        };
+    }
+    static _getSchemaApiMethodParamsBody(tableName) {
+        return {
+            "schema": {
+                "$ref": "#/components/schemas/" + tableName
+            },
+            "in": "body",
+            "required": true
+        };
+    }
+    static _getSchemaApiMethodDescription(method, tableName, hasQueryIdParam) {
+        if (hasQueryIdParam) {
+            return method.toUpperCase() + " " + tableName + " object";
+        }
+        else {
+            return method.toUpperCase() + " " + tableName + " object array";
+        }
+    }
+    static _getSchemaApiMethodOperationId(method, tableName, hasQueryIdParam) {
+        if (hasQueryIdParam) {
+            return method + tableName;
+        }
+        else {
+            return method + tableName + "All";
+        }
+    }
+    static _getSchemaOinoResponse() {
+        return {
+            "type": "object",
+            "properties": {
+                "success": {
+                    "type": "boolean"
+                },
+                "statusCode": {
+                    "type": "number"
+                },
+                "statusMessage": {
+                    "type": "string"
+                },
+                "messages": {
+                    "type": "array",
+                    "items": {
+                        "type": "string"
+                    }
+                }
+            },
+            "required": [
+                "success",
+                "statusCode",
+                "statusMessage",
+                "messages"
+            ]
+        };
+    }
+    static _getSchemaFieldType(field) {
+        let type_string;
+        if (field.type == "boolean") {
+            type_string = "boolean";
+        }
+        else if (field.type == "integer" || field.type == "number") {
+            type_string = "number";
+        }
+        else {
+            type_string = "string";
+        }
+        if (!field.fieldParams.isNotNull) {
+            return {
+                "anyOf": [
+                    {
+                        "type": type_string
+                    },
+                    {
+                        "type": "null"
+                    }
+                ]
+            };
+        }
+        else {
+            return { type: type_string };
+        }
+    }
+    static _getSwaggerApiType(api) {
+        let result = {
+            type: "object",
+            properties: {},
+            required: []
+        };
+        let field;
+        for (field of api.datamodel.fields) {
+            result.properties[field.name] = this._getSchemaFieldType(field);
+            if (field.fieldParams.isPrimaryKey) {
+                result.required.push(field.name);
+            }
+        }
+        return result;
+    }
+    static _getSchemaType(tableName, hasQueryIdParam, hasResultData) {
+        if (hasResultData && hasQueryIdParam) {
+            return { "$ref": "#/components/schemas/" + tableName };
+        }
+        else if (hasResultData) {
+            return { type: "array", items: { "$ref": "#/components/schemas/" + tableName } };
+        }
+        else if (hasQueryIdParam) {
+            return { "$ref": "#/components/schemas/OINOResponse" };
+        }
+        else {
+            return { "$ref": "#/components/schemas/OINOResponse" };
+        }
+    }
+    static _getSchemaApiMethodParams(tableName, hasQueryIdParam, hasResultData) {
+        if (hasResultData && hasQueryIdParam) {
+            return [this._getSchemaApiMethodParamsQueryId()];
+        }
+        else if (hasResultData) {
+            return [];
+        }
+        else if (hasQueryIdParam) {
+            return [this._getSchemaApiMethodParamsQueryId(), this._getSchemaApiMethodParamsBody(tableName)];
+        }
+        else {
+            return [this._getSchemaApiMethodParamsBody(tableName)];
+        }
+    }
+    static _getSchemaApiMethod(method, tableName, hasQueryIdParam, hasBody, hasResultData) {
+        return {
+            responses: {
+                200: { description: this._getSchemaApiMethodDescription(method, tableName, hasQueryIdParam), content: { "application/json": { schema: this._getSchemaType(tableName, hasQueryIdParam, hasResultData) } } }
+            },
+            "operationId": this._getSchemaApiMethodOperationId(method, tableName, hasQueryIdParam),
+            "parameters": this._getSchemaApiMethodParams(tableName, hasQueryIdParam, hasResultData)
+        };
+    }
+    static _getSwaggerApiPath(tableName, hasQueryIdParam) {
+        if (hasQueryIdParam) {
+            return {
+                get: this._getSchemaApiMethod("get", tableName, hasQueryIdParam, false, true),
+                put: this._getSchemaApiMethod("put", tableName, hasQueryIdParam, true, false),
+                delete: this._getSchemaApiMethod("delete", tableName, hasQueryIdParam, false, false)
+            };
+        }
+        else {
+            return {
+                get: this._getSchemaApiMethod("get", tableName, hasQueryIdParam, false, true),
+                post: this._getSchemaApiMethod("post", tableName, hasQueryIdParam, true, false)
+            };
+        }
+    }
+    /**
+     * Returns swagger.json as object of the given API's.
+     *
+     * @param apis array of API's use for Swagger definition
+     *
+     */
+    static getApiDefinition(apis) {
+        let result = {
+            "openapi": "3.1.0",
+            "info": {
+                "title": "",
+                "description": "",
+                "version": ""
+            },
+            "paths": {},
+            "components": {
+                "schemas": {
+                    OINOResponse: this._getSchemaOinoResponse()
+                }
+            }
+        };
+        for (let i = 0; i < apis.length; i++) {
+            const table_name = apis[i].params.tableName;
+            result.paths["/" + table_name] = this._getSwaggerApiPath(table_name, false);
+            result.paths["/" + table_name + "/{id}"] = this._getSwaggerApiPath(table_name, true);
+            result.components.schemas[table_name] = this._getSwaggerApiType(apis[i]);
+        }
+        return result;
+    }
+}
+exports.OINODbSwagger = OINODbSwagger;

package/dist/cjs/index.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OINODB_EMPTY_ROWS = exports.OINODB_EMPTY_ROW = exports.OINODbSwagger = exports.OINODbFactory = exports.OINODbConfig = exports.OINODbSqlBooleanOperation = exports.OINODbSqlLimit = exports.OINODbSqlComparison = exports.OINODbSqlOrder = exports.OINODbSqlFilter = exports.OINODbMemoryDataSet = exports.OINODbDataSet = exports.OINODb = exports.OINODatetimeDataField = exports.OINOBlobDataField = exports.OINOStringDataField = exports.OINONumberDataField = exports.OINOBooleanDataField = exports.OINODbDataField = exports.OINODbModelSet = exports.OINODbDataModel = exports.OINODbApi = exports.OINODbApiResult = exports.OINOResult = exports.OINOConsoleLog = exports.OINOLogLevel = exports.OINOLog = exports.OINOBenchmark = exports.OINOStr = exports.OINO_DEBUG_PREFIX = exports.OINO_INFO_PREFIX = exports.OINO_WARNING_PREFIX = exports.OINO_ERROR_PREFIX = exports.OINOContentType = void 0;
+const types_1 = require("@oino-ts/types");
+Object.defineProperty(exports, "OINOContentType", { enumerable: true, get: function () { return types_1.OINOContentType; } });
+var types_2 = require("@oino-ts/types");
+Object.defineProperty(exports, "OINO_ERROR_PREFIX", { enumerable: true, get: function () { return types_2.OINO_ERROR_PREFIX; } });
+Object.defineProperty(exports, "OINO_WARNING_PREFIX", { enumerable: true, get: function () { return types_2.OINO_WARNING_PREFIX; } });
+Object.defineProperty(exports, "OINO_INFO_PREFIX", { enumerable: true, get: function () { return types_2.OINO_INFO_PREFIX; } });
+Object.defineProperty(exports, "OINO_DEBUG_PREFIX", { enumerable: true, get: function () { return types_2.OINO_DEBUG_PREFIX; } });
+Object.defineProperty(exports, "OINOStr", { enumerable: true, get: function () { return types_2.OINOStr; } });
+Object.defineProperty(exports, "OINOBenchmark", { enumerable: true, get: function () { return types_2.OINOBenchmark; } });
+Object.defineProperty(exports, "OINOLog", { enumerable: true, get: function () { return types_2.OINOLog; } });
+Object.defineProperty(exports, "OINOLogLevel", { enumerable: true, get: function () { return types_2.OINOLogLevel; } });
+Object.defineProperty(exports, "OINOConsoleLog", { enumerable: true, get: function () { return types_2.OINOConsoleLog; } });
+Object.defineProperty(exports, "OINOResult", { enumerable: true, get: function () { return types_2.OINOResult; } });
+var OINODbApi_js_1 = require("./OINODbApi.js");
+Object.defineProperty(exports, "OINODbApiResult", { enumerable: true, get: function () { return OINODbApi_js_1.OINODbApiResult; } });
+Object.defineProperty(exports, "OINODbApi", { enumerable: true, get: function () { return OINODbApi_js_1.OINODbApi; } });
+var OINODbDataModel_js_1 = require("./OINODbDataModel.js");
+Object.defineProperty(exports, "OINODbDataModel", { enumerable: true, get: function () { return OINODbDataModel_js_1.OINODbDataModel; } });
+var OINODbModelSet_js_1 = require("./OINODbModelSet.js");
+Object.defineProperty(exports, "OINODbModelSet", { enumerable: true, get: function () { return OINODbModelSet_js_1.OINODbModelSet; } });
+var OINODbDataField_js_1 = require("./OINODbDataField.js");
+Object.defineProperty(exports, "OINODbDataField", { enumerable: true, get: function () { return OINODbDataField_js_1.OINODbDataField; } });
+Object.defineProperty(exports, "OINOBooleanDataField", { enumerable: true, get: function () { return OINODbDataField_js_1.OINOBooleanDataField; } });
+Object.defineProperty(exports, "OINONumberDataField", { enumerable: true, get: function () { return OINODbDataField_js_1.OINONumberDataField; } });
+Object.defineProperty(exports, "OINOStringDataField", { enumerable: true, get: function () { return OINODbDataField_js_1.OINOStringDataField; } });
+Object.defineProperty(exports, "OINOBlobDataField", { enumerable: true, get: function () { return OINODbDataField_js_1.OINOBlobDataField; } });
+Object.defineProperty(exports, "OINODatetimeDataField", { enumerable: true, get: function () { return OINODbDataField_js_1.OINODatetimeDataField; } });
+var OINODb_js_1 = require("./OINODb.js");
+Object.defineProperty(exports, "OINODb", { enumerable: true, get: function () { return OINODb_js_1.OINODb; } });
+var OINODbDataSet_js_1 = require("./OINODbDataSet.js");
+Object.defineProperty(exports, "OINODbDataSet", { enumerable: true, get: function () { return OINODbDataSet_js_1.OINODbDataSet; } });
+Object.defineProperty(exports, "OINODbMemoryDataSet", { enumerable: true, get: function () { return OINODbDataSet_js_1.OINODbMemoryDataSet; } });
+var OINODbRequestParams_js_1 = require("./OINODbRequestParams.js");
+Object.defineProperty(exports, "OINODbSqlFilter", { enumerable: true, get: function () { return OINODbRequestParams_js_1.OINODbSqlFilter; } });
+Object.defineProperty(exports, "OINODbSqlOrder", { enumerable: true, get: function () { return OINODbRequestParams_js_1.OINODbSqlOrder; } });
+Object.defineProperty(exports, "OINODbSqlComparison", { enumerable: true, get: function () { return OINODbRequestParams_js_1.OINODbSqlComparison; } });
+Object.defineProperty(exports, "OINODbSqlLimit", { enumerable: true, get: function () { return OINODbRequestParams_js_1.OINODbSqlLimit; } });
+Object.defineProperty(exports, "OINODbSqlBooleanOperation", { enumerable: true, get: function () { return OINODbRequestParams_js_1.OINODbSqlBooleanOperation; } });
+var OINODbConfig_js_1 = require("./OINODbConfig.js");
+Object.defineProperty(exports, "OINODbConfig", { enumerable: true, get: function () { return OINODbConfig_js_1.OINODbConfig; } });
+var OINODbFactory_js_1 = require("./OINODbFactory.js");
+Object.defineProperty(exports, "OINODbFactory", { enumerable: true, get: function () { return OINODbFactory_js_1.OINODbFactory; } });
+var OINODbSwagger_js_1 = require("./OINODbSwagger.js");
+Object.defineProperty(exports, "OINODbSwagger", { enumerable: true, get: function () { return OINODbSwagger_js_1.OINODbSwagger; } });
+/** Empty row instance */
+exports.OINODB_EMPTY_ROW = [];
+/** Empty row array instance */
+exports.OINODB_EMPTY_ROWS = [exports.OINODB_EMPTY_ROW];

package/dist/esm/OINODb.js

@@ -0,0 +1,23 @@
+/*
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+/**
+ * Base class for database abstraction, implementing methods for connecting, making queries and parsing/formatting data
+ * between SQL and serialization formats.
+ *
+ */
+export class OINODb {
+    _params;
+    /** Name of the database */
+    name;
+    /**
+     * Constructor for `OINODb`.
+     * @param params database parameters
+     */
+    constructor(params) {
+        this._params = params;
+        this.name = params.database;
+    }
+}