@oino-ts/db 0.0.11

package/dist/cjs/OINODbModelSet.js

@@ -0,0 +1,267 @@
+"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.OINODbModelSet = void 0;
+const index_js_1 = require("./index.js");
+/**
+ * Class for dataset based on a data model that can be serialized to
+ * a supported format:
+ * - JSON (application/json)
+ * - CSV (text/csv)
+ *
+ */
+class OINODbModelSet {
+    /** Reference to datamodel */
+    datamodel;
+    /** Reference to data set */
+    dataset;
+    /** Collection of errors */
+    errors;
+    /**
+     * Constructor for `OINODbModelSet`.
+     *
+     * @param datamodel data model
+     * @param dataset data set
+     */
+    constructor(datamodel, dataset) {
+        this.datamodel = datamodel;
+        this.dataset = dataset;
+        this.errors = this.dataset.messages;
+    }
+    _encodeAndHashFieldValue(field, value, contentType, primaryKeyValues, rowIdSeed) {
+        if (field.fieldParams.isPrimaryKey) {
+            if (value && (field instanceof index_js_1.OINONumberDataField) && (this.datamodel.api.hashid)) {
+                value = this.datamodel.api.hashid.encode(value, rowIdSeed);
+            }
+            primaryKeyValues.push(value || "");
+        }
+        value = index_js_1.OINOStr.encode(value, contentType);
+        return value;
+    }
+    _writeRowJson(row) {
+        // console.log("OINODbModelSet._writeRowJson: row=" + row)
+        const model = this.datamodel;
+        const fields = model.fields;
+        let row_id_seed = model.getRowPrimarykeyValues(row).join(' ');
+        let primary_key_values = [];
+        let json_row = "";
+        for (let i = 0; i < fields.length; i++) {
+            const f = fields[i];
+            let value = f.serializeCell(row[i]);
+            if (value === undefined) {
+                index_js_1.OINOLog.info("OINODbModelSet._writeRowJson: undefined value skipped", { field_name: f.name });
+            }
+            else if (value === null) {
+                json_row += "," + index_js_1.OINOStr.encode(f.name, index_js_1.OINOContentType.json) + ":null";
+            }
+            else {
+                let is_hashed = f.fieldParams.isPrimaryKey && (f instanceof index_js_1.OINONumberDataField) && (this.datamodel.api.hashid != null);
+                let is_value = (f instanceof index_js_1.OINOBooleanDataField) || ((f instanceof index_js_1.OINONumberDataField) && !is_hashed);
+                value = this._encodeAndHashFieldValue(f, value, index_js_1.OINOContentType.json, primary_key_values, f.name + " " + row_id_seed);
+                if (is_value) {
+                    value = value.substring(1, value.length - 1);
+                }
+                json_row += "," + index_js_1.OINOStr.encode(f.name, index_js_1.OINOContentType.json) + ":" + value;
+            }
+        }
+        json_row = index_js_1.OINOStr.encode(index_js_1.OINODbConfig.OINODB_ID_FIELD, index_js_1.OINOContentType.json) + ":" + index_js_1.OINOStr.encode(index_js_1.OINODbConfig.printOINOId(primary_key_values), index_js_1.OINOContentType.json) + json_row;
+        // OINOLog_debug("OINODbModelSet._writeRowJson="+json_row)
+        return "{" + json_row + "}";
+    }
+    _writeStringJson() {
+        let result = "";
+        while (!this.dataset.isEof()) {
+            if (result != "") {
+                result += ",\r\n";
+            }
+            result += this._writeRowJson(this.dataset.getRow());
+            this.dataset.next();
+        }
+        result = "[\r\n" + result + "\r\n]";
+        // OINOLog_debug("OINODbModelSet._writeStringJson="+result)
+        return result;
+    }
+    _writeHeaderCsv() {
+        const model = this.datamodel;
+        const fields = model.fields;
+        let csv_header = "\"" + index_js_1.OINODbConfig.OINODB_ID_FIELD + "\"";
+        for (let i = 0; i < fields.length; i++) {
+            csv_header += ",\"" + fields[i].name + "\"";
+        }
+        // OINOLog_debug("OINODbModelSet._writeHeaderCsv="+csv_header)
+        return csv_header;
+    }
+    _writeRowCsv(row) {
+        // OINOLog_debug("OINODbModelSet._writeRowCsv", {row:row})
+        const model = this.datamodel;
+        const fields = model.fields;
+        let row_id_seed = model.getRowPrimarykeyValues(row).join(' ');
+        let primary_key_values = [];
+        let csv_row = "";
+        for (let i = 0; i < fields.length; i++) {
+            const f = fields[i];
+            let value = f.serializeCell(row[i]);
+            if (value == null) {
+                csv_row += "," + index_js_1.OINOStr.encode(value, index_js_1.OINOContentType.csv); // either null or undefined
+            }
+            else {
+                value = this._encodeAndHashFieldValue(f, value, index_js_1.OINOContentType.csv, primary_key_values, f.name + " " + row_id_seed);
+                csv_row += "," + value;
+            }
+        }
+        csv_row = index_js_1.OINOStr.encode(index_js_1.OINODbConfig.printOINOId(primary_key_values), index_js_1.OINOContentType.csv) + csv_row;
+        // OINOLog_debug("OINODbModelSet._writeRowCsv="+csv_row)
+        return csv_row;
+    }
+    _writeStringCsv() {
+        let result = this._writeHeaderCsv();
+        while (!this.dataset.isEof()) {
+            if (result != "") {
+                result += "\r\n";
+            }
+            result += this._writeRowCsv(this.dataset.getRow());
+            this.dataset.next();
+        }
+        // OINOLog_debug("OINODbModelSet._writeStringCsv="+result)
+        return result;
+    }
+    _writeRowFormdataParameterBlock(blockName, blockValue, multipartBoundary) {
+        if (blockValue === null) {
+            return multipartBoundary + "\r\n" + "Content-Disposition: form-data; name=\"" + blockName + "\"\r\n\r\n";
+        }
+        else {
+            return multipartBoundary + "\r\n" + "Content-Disposition: form-data; name=\"" + blockName + "\"\r\n\r\n" + blockValue + "\r\n";
+        }
+    }
+    _writeRowFormdataFileBlock(blockName, blockValue, multipartBoundary) {
+        return multipartBoundary + "\r\n" + "Content-Disposition: form-data; name=\"" + blockName + "\"; filename=" + blockName + "\"\r\nContent-Type: application/octet-stream\r\nContent-Transfer-Encoding: BASE64\r\n\r\n" + blockValue + "\r\n";
+    }
+    _writeRowFormdata(row) {
+        const multipart_boundary = "---------OINOMultipartBoundary35424568"; // this method is just used for test data generation and we want it to be static
+        const model = this.datamodel;
+        const fields = model.fields;
+        let row_id_seed = model.getRowPrimarykeyValues(row).join(' ');
+        let primary_key_values = [];
+        let result = "";
+        for (let i = 0; i < fields.length; i++) {
+            const f = fields[i];
+            let value = f.serializeCell(row[i]);
+            let formdata_block = "";
+            let is_file = (f instanceof index_js_1.OINOBlobDataField);
+            if (value === undefined) {
+                index_js_1.OINOLog.info("OINODbModelSet._writeRowFormdata: undefined value skipped.", { field: f.name });
+            }
+            else if (value === null) {
+                formdata_block = this._writeRowFormdataParameterBlock(fields[i].name, null, multipart_boundary);
+            }
+            else {
+                value = this._encodeAndHashFieldValue(f, value, index_js_1.OINOContentType.formdata, primary_key_values, f.name + " " + row_id_seed);
+                if (is_file) {
+                    formdata_block = this._writeRowFormdataFileBlock(f.name, value, multipart_boundary);
+                }
+                else {
+                    formdata_block = this._writeRowFormdataParameterBlock(fields[i].name, value, multipart_boundary);
+                }
+            }
+            // OINOLog.debug("OINODbModelSet._writeRowFormdata next block", {formdata_block:formdata_block})
+            result += formdata_block;
+        }
+        result = this._writeRowFormdataParameterBlock(index_js_1.OINODbConfig.OINODB_ID_FIELD, index_js_1.OINODbConfig.printOINOId(primary_key_values), multipart_boundary) + result;
+        return result;
+    }
+    _writeStringFormdata() {
+        let result = this._writeRowFormdata(this.dataset.getRow());
+        this.dataset.next();
+        if (!this.dataset.isEof()) {
+            index_js_1.OINOLog.warning("OINODbModelSet._writeStringUrlencode: content type " + index_js_1.OINOContentType.formdata + " does not mixed part content and only first row has been written!");
+        }
+        return result;
+    }
+    _writeRowUrlencode(row) {
+        // console.log("OINODbModelSet._writeRowCsv row=" + row)
+        const model = this.datamodel;
+        const fields = model.fields;
+        let row_id_seed = model.getRowPrimarykeyValues(row).join(' ');
+        let primary_key_values = [];
+        let urlencode_row = "";
+        for (let i = 0; i < fields.length; i++) {
+            const f = fields[i];
+            let value = f.serializeCell(row[i]);
+            if ((value === undefined)) { // || (value === null)) {
+                // console.log("OINODbModelSet._writeRowUrlencode undefined field value:" + fields[i].name)
+            }
+            else {
+                value = this._encodeAndHashFieldValue(f, value, index_js_1.OINOContentType.urlencode, primary_key_values, f.name + " " + row_id_seed);
+                if (urlencode_row != "") {
+                    urlencode_row += "&";
+                }
+                urlencode_row += index_js_1.OINOStr.encode(f.name, index_js_1.OINOContentType.urlencode) + "=" + value;
+            }
+        }
+        urlencode_row = index_js_1.OINOStr.encode(index_js_1.OINODbConfig.OINODB_ID_FIELD, index_js_1.OINOContentType.urlencode) + "=" + index_js_1.OINOStr.encode(index_js_1.OINODbConfig.printOINOId(primary_key_values), index_js_1.OINOContentType.urlencode) + "&" + urlencode_row;
+        // OINOLog_debug("OINODbModelSet._writeRowCsv="+csv_row)
+        return urlencode_row;
+    }
+    _writeStringUrlencode() {
+        let result = "";
+        let line_count = 0;
+        while (!this.dataset.isEof()) {
+            result += this._writeRowUrlencode(this.dataset.getRow()) + "\r\n";
+            this.dataset.next();
+            line_count += 1;
+        }
+        // OINOLog_debug("OINODbModelSet._writeStringCsv="+result)
+        if (line_count > 1) {
+            index_js_1.OINOLog.warning("OINODbModelSet._writeStringUrlencode: content type " + index_js_1.OINOContentType.urlencode + " does not officially support multiline content!");
+        }
+        return result;
+    }
+    /**
+     * Serialize model set in the given format.
+     *
+     * @param [contentType=OINOContentType.json] serialization content type
+     *
+     */
+    writeString(contentType = index_js_1.OINOContentType.json) {
+        let result = "";
+        if (contentType == index_js_1.OINOContentType.csv) {
+            result += this._writeStringCsv();
+        }
+        else if (contentType == index_js_1.OINOContentType.json) {
+            result += this._writeStringJson();
+        }
+        else if (contentType == index_js_1.OINOContentType.formdata) {
+            result += this._writeStringFormdata();
+        }
+        else if (contentType == index_js_1.OINOContentType.urlencode) {
+            result += this._writeStringUrlencode();
+        }
+        else {
+            index_js_1.OINOLog.error("OINODbModelSet.writeString: content type is only for input!", { contentType: contentType });
+        }
+        return result;
+    }
+    /**
+     * Get value of given field in the current row. Undefined if no rows,
+     * field not found or value does not exist.
+     *
+     * @param fieldName name of the field
+     *
+     */
+    getValueByFieldName(fieldName) {
+        let result = undefined;
+        if (!this.dataset.isEof()) {
+            const current_row = this.dataset.getRow();
+            const field_index = this.datamodel.findFieldIndexByName(fieldName);
+            if (field_index >= 0) {
+                result = current_row[field_index];
+            }
+        }
+        return result;
+    }
+}
+exports.OINODbModelSet = OINODbModelSet;

package/dist/cjs/OINODbParams.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.OINODbLimit = exports.OINODbOrder = exports.OINODbFilter = exports.OINODbComparison = exports.OINODbBooleanOperation = void 0;
+const index_js_1 = require("./index.js");
+/**
+ * Supported logical conjunctions in filter predicates.
+ * @enum
+ */
+var OINODbBooleanOperation;
+(function (OINODbBooleanOperation) {
+    OINODbBooleanOperation["and"] = "and";
+    OINODbBooleanOperation["or"] = "or";
+    OINODbBooleanOperation["not"] = "not";
+})(OINODbBooleanOperation || (exports.OINODbBooleanOperation = OINODbBooleanOperation = {}));
+/**
+ * Supported logical conjunctions in filter predicates.
+ * @enum
+ */
+var OINODbComparison;
+(function (OINODbComparison) {
+    OINODbComparison["lt"] = "lt";
+    OINODbComparison["le"] = "le";
+    OINODbComparison["eq"] = "eq";
+    OINODbComparison["ge"] = "ge";
+    OINODbComparison["gt"] = "gt";
+    OINODbComparison["like"] = "like";
+})(OINODbComparison || (exports.OINODbComparison = OINODbComparison = {}));
+/**
+ * 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 OINODbFilter {
+    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 `OINODbFilter`
+     * @param leftSide left side of the filter, either another filter or a column name
+     * @param operation operation of the filter, either `OINODbComparison` or `OINODbBooleanOperation`
+     * @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(OINODbComparison).includes(operation)) && (typeof (leftSide) == "string") && (leftSide != "") && (typeof (rightSide) == "string") && (rightSide != "")) ||
+            ((operation == OINODbBooleanOperation.not) && (leftSide == "") && (rightSide instanceof OINODbFilter)) ||
+            (((operation == OINODbBooleanOperation.and) || (operation == OINODbBooleanOperation.or)) && (leftSide instanceof OINODbFilter) && (rightSide instanceof OINODbFilter)))) {
+            index_js_1.OINOLog.debug("Unsupported OINODbFilter format!", { leftSide: leftSide, operation: operation, rightSide: rightSide });
+            throw new Error(index_js_1.OINODB_ERROR_PREFIX + ": Unsupported OINODbFilter 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 OINODbFilter("", null, "");
+        }
+        else {
+            let match = OINODbFilter._filterComparisonRegex.exec(filterString);
+            if (match != null) {
+                return new OINODbFilter(match[1], match[2].toLowerCase(), match[3]);
+            }
+            else {
+                let match = OINODbFilter._negationRegex.exec(filterString);
+                if (match != null) {
+                    return new OINODbFilter("", OINODbBooleanOperation.not, OINODbFilter.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(OINODbFilter._booleanOperationRegex))) {
+                        return new OINODbFilter(OINODbFilter.parse(boolean_parts[0]), boolean_parts[1].trim().toLowerCase().substring(1), OINODbFilter.parse(boolean_parts[2]));
+                    }
+                    else {
+                        throw new Error(index_js_1.OINODB_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 OINODbFilter(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 OINODbFilter) {
+            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 OINODbFilter) {
+            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.OINODbFilter = OINODbFilter;
+/**
+ * Class for ordering select results on a number of columns.
+ *
+ */
+class OINODbOrder {
+    static _orderColumnRegex = /^\s*(\w+)\s?(ASC|DESC)?\s*?$/i;
+    _columns;
+    _directions;
+    /**
+     * Constructor for `OINODbOrder`.
+     *
+     * @param orderString string representation of filter from HTTP-request
+     *
+     */
+    constructor(orderString) {
+        // OINOLog.debug("OINODbOrder.constructor", {orderString:orderString})
+        this._columns = [];
+        this._directions = [];
+        const column_strings = orderString.split(',');
+        for (let i = 0; i < column_strings.length; i++) {
+            let match = OINODbOrder._orderColumnRegex.exec(column_strings[i]);
+            if (match != null) {
+                this._columns.push(match[1]);
+                this._directions.push((match[2] || "ASC").toUpperCase());
+            }
+        }
+        // OINOLog.debug("OINODbOrder.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("OINODbOrder.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("OINODbOrder.toSql", {result:result})
+        return result;
+    }
+}
+exports.OINODbOrder = OINODbOrder;
+/**
+ * Class for limiting the number of results.
+ *
+ */
+class OINODbLimit {
+    static _orderColumnRegex = /^(\d+)?$/i;
+    _limit;
+    /**
+     * Constructor for `OINODbLimit`.
+     *
+     * @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.OINODbLimit = OINODbLimit;