@oino-ts/db 0.0.16 → 0.0.18

package/dist/cjs/OINODbModelSet.js

@@ -34,11 +34,13 @@ class OINODbModelSet {
     }
     _encodeAndHashFieldValue(field, value, contentType, primaryKeyValues, rowIdSeed) {
         let result;
-        if (field.fieldParams.isPrimaryKey) {
+        if (field.fieldParams.isPrimaryKey || field.fieldParams.isForeignKey) {
             if (value && (field instanceof index_js_1.OINONumberDataField) && (this.datamodel.api.hashid)) {
                 value = this.datamodel.api.hashid.encode(value, rowIdSeed);
             }
-            primaryKeyValues.push(value || "");
+            if (field.fieldParams.isPrimaryKey) {
+                primaryKeyValues.push(value || "");
+            }
         }
         result = index_js_1.OINOStr.encode(value, contentType);
         return result;
@@ -54,13 +56,13 @@ class OINODbModelSet {
             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 });
+                // 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_hashed = (f.fieldParams.isPrimaryKey || f.fieldParams.isForeignKey) && (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) {

package/dist/cjs/OINODbRequestParams.js

@@ -92,7 +92,7 @@ class OINODbSqlFilter {
                         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 + "'");
+                        throw new Error(index_js_1.OINO_ERROR_PREFIX + ": Invalid filter '" + filterString + "'"); // invalid filter could be a security risk, stop processing
                     }
                 }
             }
@@ -158,20 +158,24 @@ class OINODbSqlFilter {
             result += this._leftSide.toSql(dataModel);
         }
         else {
-            result += dataModel.api.db.printSqlColumnname(this._leftSide);
             field = dataModel.findFieldByName(this._leftSide);
+            if (!field) {
+                index_js_1.OINOLog.error("OINODbSqlFilter.toSql: Invalid field!", { field: this._leftSide });
+                throw new Error(index_js_1.OINO_ERROR_PREFIX + ": OINODbSqlFilter.toSql - Invalid field '" + this._leftSide + "'"); // invalid field name could be a security risk, stop processing
+            }
+            result += dataModel.api.db.printSqlColumnname(field?.name || 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;
+            const value = field.deserializeCell(this._rightSide);
+            if (!value) {
+                index_js_1.OINOLog.error("OINODbSqlFilter.toSql: Invalid value!", { value: value });
+                throw new Error(index_js_1.OINO_ERROR_PREFIX + ": OINODbSqlFilter.toSql - Invalid value '" + value + "'"); // invalid value could be a security risk, stop processing
             }
+            result += field.printCellAsSqlValue(value);
         }
         // OINOLog.debug("OINOFilter.toSql", {result:result})
         return "(" + result + ")";
@@ -248,17 +252,19 @@ class OINODbSqlOrder {
         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) + " ";
-                if (this._descending[i]) {
-                    result += "DESC";
-                }
-                else {
-                    result += "ASC";
-                }
+            if (!field) {
+                index_js_1.OINOLog.error("OINODbSqlOrder.toSql: Invalid field!", { field: this._columns[i] });
+                throw new Error(index_js_1.OINO_ERROR_PREFIX + ": OINODbSqlOrder.toSql - Invalid field '" + this._columns[i] + "'"); // invalid field name could be a security risk, stop processing
+            }
+            if (result) {
+                result += ",";
+            }
+            result += dataModel.api.db.printSqlColumnname(field.name) + " ";
+            if (this._descending[i]) {
+                result += "DESC";
+            }
+            else {
+                result += "ASC";
             }
         }
         // OINOLog.debug("OINODbSqlOrder.toSql", {result:result})
@@ -271,16 +277,18 @@ exports.OINODbSqlOrder = OINODbSqlOrder;
  *
  */
 class OINODbSqlLimit {
-    static _orderColumnRegex = /^(\d+)?$/i;
+    static _limitRegex = /^(\d+)(\spage\s)?(\d+)?$/i;
     _limit;
+    _page;
     /**
      * Constructor for `OINODbSqlLimit`.
      *
      * @param limit maximum number of items to return
      *
      */
-    constructor(limit) {
+    constructor(limit, page = -1) {
         this._limit = limit;
+        this._page = page;
     }
     /**
      * Constructor for `OINODbSqlLimit` as parser of http parameter.
@@ -289,10 +297,14 @@ class OINODbSqlLimit {
      *
      */
     static parse(limitString) {
-        try {
-            return new OINODbSqlLimit(Number.parseInt(limitString));
+        let match = OINODbSqlLimit._limitRegex.exec(limitString);
+        if ((match != null) && (match.length == 4)) {
+            return new OINODbSqlLimit(Number.parseInt(match[1]), Number.parseInt(match[3]));
         }
-        catch {
+        else if (match != null) {
+            return new OINODbSqlLimit(Number.parseInt(match[1]));
+        }
+        else {
             return new OINODbSqlLimit(-1);
         }
     }
@@ -314,6 +326,9 @@ class OINODbSqlLimit {
             return "";
         }
         let result = this._limit.toString();
+        if (this._page > 0) {
+            result += " OFFSET " + (this._limit * (this._page - 1) + 1).toString();
+        }
         return result;
     }
 }

package/dist/cjs/OINODbSqlParams.js

@@ -0,0 +1,336 @@
+"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 + "'"); // invalid filter could be a security risk, stop processing
+                    }
+                }
+            }
+        }
+    }
+    /**
+     * 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 {
+            field = dataModel.findFieldByName(this._leftSide);
+            if (!field) {
+                index_js_1.OINOLog.error("OINODbSqlFilter.toSql: Invalid field!", { field: this._leftSide });
+                throw new Error(index_js_1.OINO_ERROR_PREFIX + ": OINODbSqlFilter.toSql - Invalid field '" + this._leftSide + "'"); // invalid field name could be a security risk, stop processing
+            }
+            result += dataModel.api.db.printSqlColumnname(field?.name || this._leftSide);
+        }
+        result += this._operatorToSql();
+        if (this._rightSide instanceof OINODbSqlFilter) {
+            result += this._rightSide.toSql(dataModel);
+        }
+        else {
+            const value = field.deserializeCell(this._rightSide);
+            if (!value) {
+                index_js_1.OINOLog.error("OINODbSqlFilter.toSql: Invalid value!", { value: value });
+                throw new Error(index_js_1.OINO_ERROR_PREFIX + ": OINODbSqlFilter.toSql - Invalid value '" + value + "'"); // invalid value could be a security risk, stop processing
+            }
+            result += field.printCellAsSqlValue(value);
+        }
+        // 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;
+    _descending;
+    /**
+     * Constructor for `OINODbSqlOrder`.
+     *
+     * @param column_or_array single or array of columns to order on
+     * @param descending_or_array single or array of booleans if ordes is descending
+     *
+     */
+    constructor(column_or_array, descending_or_array) {
+        index_js_1.OINOLog.debug("OINODbSqlOrder.constructor", { columns: column_or_array, directions: descending_or_array });
+        if (Array.isArray(column_or_array)) {
+            this._columns = column_or_array;
+        }
+        else {
+            this._columns = [column_or_array];
+        }
+        if (Array.isArray(descending_or_array)) {
+            this._descending = descending_or_array;
+        }
+        else {
+            this._descending = [descending_or_array];
+        }
+    }
+    /**
+     * Constructor for `OINODbSqlOrder` as parser of http parameter.
+     *
+     * @param orderString string representation of ordering from HTTP-request
+     *
+     */
+    static parse(orderString) {
+        let columns = [];
+        let 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) {
+                columns.push(match[1]);
+                directions.push((match[2] || "DESC").toUpperCase() == "DESC");
+            }
+        }
+        return new OINODbSqlOrder(columns, 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) {
+                index_js_1.OINOLog.error("OINODbSqlOrder.toSql: Invalid field!", { field: this._columns[i] });
+                throw new Error(index_js_1.OINO_ERROR_PREFIX + ": OINODbSqlOrder.toSql - Invalid field '" + this._columns[i] + "'"); // invalid field name could be a security risk, stop processing
+            }
+            if (result) {
+                result += ",";
+            }
+            result += dataModel.api.db.printSqlColumnname(field.name) + " ";
+            if (this._descending[i]) {
+                result += "DESC";
+            }
+            else {
+                result += "ASC";
+            }
+        }
+        // OINOLog.debug("OINODbSqlOrder.toSql", {result:result})
+        return result;
+    }
+}
+exports.OINODbSqlOrder = OINODbSqlOrder;
+/**
+ * Class for limiting the number of results.
+ *
+ */
+class OINODbSqlLimit {
+    static _limitRegex = /^(\d+)(\spage\s)?(\d+)?$/i;
+    _limit;
+    _page;
+    /**
+     * Constructor for `OINODbSqlLimit`.
+     *
+     * @param limit maximum number of items to return
+     * @param page page number to return starting from 1
+     *
+     */
+    constructor(limit, page = -1) {
+        this._limit = limit;
+        this._page = page;
+    }
+    /**
+     * Constructor for `OINODbSqlLimit` as parser of http parameter.
+     *
+     * @param limitString string representation of limit from HTTP-request
+     *
+     */
+    static parse(limitString) {
+        let match = OINODbSqlLimit._limitRegex.exec(limitString);
+        if ((match != null) && (match.length == 4)) {
+            return new OINODbSqlLimit(Number.parseInt(match[1]), Number.parseInt(match[3]));
+        }
+        else if (match != null) {
+            return new OINODbSqlLimit(Number.parseInt(match[1]));
+        }
+        else {
+            return new OINODbSqlLimit(-1);
+        }
+    }
+    /**
+     * 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();
+        if (this._page > 0) {
+            result += " OFFSET " + (this._limit * (this._page - 1) + 1).toString();
+        }
+        return result;
+    }
+}
+exports.OINODbSqlLimit = OINODbSqlLimit;

package/dist/cjs/index.js

@@ -36,12 +36,12 @@ Object.defineProperty(exports, "OINODb", { enumerable: true, get: function () {
 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 OINODbSqlParams_js_1 = require("./OINODbSqlParams.js");
+Object.defineProperty(exports, "OINODbSqlFilter", { enumerable: true, get: function () { return OINODbSqlParams_js_1.OINODbSqlFilter; } });
+Object.defineProperty(exports, "OINODbSqlOrder", { enumerable: true, get: function () { return OINODbSqlParams_js_1.OINODbSqlOrder; } });
+Object.defineProperty(exports, "OINODbSqlComparison", { enumerable: true, get: function () { return OINODbSqlParams_js_1.OINODbSqlComparison; } });
+Object.defineProperty(exports, "OINODbSqlLimit", { enumerable: true, get: function () { return OINODbSqlParams_js_1.OINODbSqlLimit; } });
+Object.defineProperty(exports, "OINODbSqlBooleanOperation", { enumerable: true, get: function () { return OINODbSqlParams_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");

package/dist/esm/OINODb.js

@@ -20,4 +20,30 @@ export class OINODb {
         this._params = params;
         this.name = params.database;
     }
+    /**
+     * Print SQL select statement with DB specific formatting.
+     *
+     * @param tableName - The name of the table to select from.
+     * @param columnNames - The columns to be selected.
+     * @param whereCondition - The WHERE clause to filter the results.
+     * @param orderCondition - The ORDER BY clause to sort the results.
+     * @param limitCondition - The LIMIT clause to limit the number of results.
+     *
+     */
+    printSqlSelect(tableName, columnNames, whereCondition, orderCondition, limitCondition) {
+        let result = "SELECT " + columnNames + " FROM " + tableName;
+        // OINOLog.debug("OINODb.printSqlSelect", {tableName:tableName, columnNames:columnNames, whereCondition:whereCondition, orderCondition:orderCondition, limitCondition:limitCondition })
+        if (whereCondition != "") {
+            result += " WHERE " + whereCondition;
+        }
+        if (orderCondition != "") {
+            result += " ORDER BY " + orderCondition;
+        }
+        if (limitCondition != "") {
+            result += " LIMIT " + limitCondition;
+        }
+        result += ";";
+        // OINOLog.debug("OINODb.printSqlSelect", {result:result})
+        return result;
+    }
 }

package/dist/esm/OINODbApi.js

@@ -3,9 +3,10 @@
  * 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/.
  */
-import { OINODbDataModel, OINOStringDataField, OINO_ERROR_PREFIX, OINODbModelSet, OINOBenchmark, OINODbFactory, OINODbConfig, OINOHtmlTemplate, OINONumberDataField } from "./index.js";
+import { OINODbDataModel, OINOStringDataField, OINO_ERROR_PREFIX, OINODbModelSet, OINOBenchmark, OINODbConfig, OINOHtmlTemplate, OINONumberDataField } from "./index.js";
 import { OINOResult } from "@oino-ts/types";
 import { OINOHashid } from "@oino-ts/hashid";
+import { OINOParser } from "@oino-ts/types";
 const API_EMPTY_PARAMS = { sqlParams: {} };
 /**
  * OINO API request result object with returned data and/or http status code/message and
@@ -35,7 +36,7 @@ export class OINODbApiResult extends OINOResult {
      * @param headers Headers to include in the response
      *
      */
-    async createResponseFromResult(headers = {}) {
+    async getResponse(headers = {}) {
         let response = null;
         if (this.success && this.data) {
             const body = await this.data.writeString(this.params.responseType);
@@ -85,11 +86,13 @@ export class OINODbHtmlTemplate extends OINOHtmlTemplate {
             for (let i = 0; i < datamodel.fields.length; i++) {
                 const f = datamodel.fields[i];
                 let value = f.serializeCell(row[i]);
-                if (f.fieldParams.isPrimaryKey) {
+                if (f.fieldParams.isPrimaryKey || f.fieldParams.isForeignKey) {
                     if (value && (f instanceof OINONumberDataField) && (datamodel.api.hashid)) {
                         value = datamodel.api.hashid.encode(value, f.name + " " + row_id_seed);
                     }
-                    primary_key_values.push(value || "");
+                    if (f.fieldParams.isPrimaryKey) {
+                        primary_key_values.push(value || "");
+                    }
                 }
                 // OINOLog.debug("renderFromDbData replace field value", {field:f.name, value:value }) 
                 this.setVariableFromValue(f.name, value || "");
@@ -177,9 +180,10 @@ export class OINODbApi {
         //logDebug("OINODbApi.validateHttpValues", {result:result})
     }
     async _doGet(result, id, params) {
-        const sql = this.datamodel.printSqlSelect(id, params.sqlParams || {});
-        // OINOLog.debug("OINODbApi.doGet sql", {sql:sql})
+        let sql = "";
         try {
+            sql = this.datamodel.printSqlSelect(id, params.sqlParams || {});
+            // OINOLog.debug("OINODbApi.doGet sql", {sql:sql})
             const sql_res = await this.db.sqlSelect(sql);
             // OINOLog.debug("OINODbApi.doGet sql_res", {sql_res:sql_res})
             if (sql_res.hasErrors()) {
@@ -282,14 +286,16 @@ export class OINODbApi {
         let result = new OINODbApiResult(params);
         let rows = [];
         if ((method == "POST") || (method == "PUT")) {
-            if (Array.isArray(body)) {
-                rows = body;
-            }
-            else if (typeof (body) == "object") {
-                rows = [OINODbFactory.createRowFromObject(this.datamodel, body)];
+            try {
+                if (Array.isArray(body)) {
+                    rows = body;
+                }
+                else {
+                    rows = OINOParser.createRows(this.datamodel, body, params);
+                }
             }
-            else if (typeof (body) == "string") {
-                rows = OINODbFactory.createRows(this.datamodel, body, params);
+            catch (e) {
+                result.setError(400, "Invalid data: " + e.message, "DoRequest");
             }
             // OINOLog.debug("OINODbApi.doRequest - OINODataRow rows", {rows:rows})        
         }

package/dist/esm/OINODbDataField.js

@@ -3,6 +3,7 @@
  * 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/.
  */
+import { OINOLog, OINO_ERROR_PREFIX } from "./index.js";
 /**
  * Base class for a column of data responsible for appropriatelly serializing/deserializing the data.
  *
@@ -51,6 +52,9 @@ export class OINODbDataField {
         if (this.fieldParams.isPrimaryKey) {
             params += "PK ";
         }
+        if (this.fieldParams.isForeignKey) {
+            params += "FK ";
+        }
         if (this.fieldParams.isAutoInc) {
             params += "AUTOINC ";
         }
@@ -236,7 +240,12 @@ export class OINONumberDataField extends OINODbDataField {
             return null;
         }
         else {
-            return Number.parseFloat(value);
+            const result = parseFloat(value);
+            if (isNaN(result)) {
+                OINOLog.error("OINODbSqlFilter.toSql: Invalid value!", { value: value });
+                throw new Error(OINO_ERROR_PREFIX + ": OINONumberDataField.deserializeCell - Invalid value '" + value + "'"); // incorrectly formatted data could be a security risk, abort processing
+            }
+            return result;
         }
     }
 }
@@ -284,7 +293,7 @@ export class OINOBlobDataField extends OINODbDataField {
      */
     deserializeCell(value) {
         if (value == null) {
-            return new Buffer(0);
+            return Buffer.alloc(0);
         }
         else {
             return Buffer.from(value, 'base64'); // Blob-field data is base64 encoded and converted internally to UInt8Array / Buffer