@oino-ts/common 0.21.1 → 1.0.0

package/dist/cjs/OINODataField.js

@@ -0,0 +1,346 @@
+"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.OINODatetimeDataField = exports.OINOBlobDataField = exports.OINONumberDataField = exports.OINOBooleanDataField = exports.OINOStringDataField = exports.OINODataField = void 0;
+const node_buffer_1 = require("node:buffer");
+const OINOConstants_js_1 = require("./OINOConstants.js");
+const OINOLog_js_1 = require("./OINOLog.js");
+/**
+ * Base class for a column of data responsible for appropriatelly serializing/deserializing the data.
+ *
+ */
+class OINODataField {
+    /** OINO data source reference*/
+    datasource;
+    /** Name of the field */
+    name;
+    /** Internal type of field*/
+    type;
+    /** SQL type of the field */
+    nativeType;
+    /** Maximum length of the field (or 0) */
+    maxLength;
+    /** Parameters for the field */
+    fieldParams;
+    /**
+     * Constructor for a data field
+     *
+     * @param datasource OINO data source reference
+     * @param name name of the field
+     * @param type internal type of the field
+     * @param nativeType column type in database
+     * @param fieldParams parameters of the field
+     * @param maxLength maximum length of the field (or 0)
+     *
+     */
+    constructor(datasource, name, type, nativeType, fieldParams, maxLength = 0) {
+        this.datasource = datasource;
+        this.name = name;
+        this.type = type;
+        this.maxLength = maxLength;
+        this.nativeType = nativeType;
+        this.fieldParams = fieldParams;
+    }
+    /**
+     * Serialize cell value in the given content format.
+     *
+     * @param cellVal cell value
+     *
+     */
+    serializeCell(cellVal) {
+        cellVal = this.datasource.parseValueAsCell(cellVal, this.nativeType);
+        if ((cellVal === null) || (cellVal === undefined)) {
+            return cellVal; // let content type encoder worry what to do with the value (so not force it to string)
+        }
+        else {
+            return cellVal.toString();
+        }
+    }
+    /**
+     * Parce cell value from string using field type specific formatting rules.
+     *
+     * @param value string value
+     *
+     */
+    deserializeCell(value) {
+        return value;
+    }
+    /**
+     * Print data cell (from deserialization) as SQL-string.
+     *
+     * @param cellVal cell value
+     *
+     */
+    printCellAsValue(cellVal) {
+        return this.datasource.printCellAsValue(cellVal, this.nativeType);
+    }
+    /**
+     * Print name of column as SQL.
+     *
+     */
+    printColumnName() {
+        return this.datasource.printColumnName(this.name);
+    }
+}
+exports.OINODataField = OINODataField;
+/**
+ * Specialised class for a string column.
+ *
+ */
+class OINOStringDataField extends OINODataField {
+    /**
+     * Constructor for a string data field
+     *
+     * @param datasource OINO data source reference
+     * @param name name of the field
+     * @param nativeType column type in database
+     * @param fieldParams parameters of the field
+     * @param maxLength maximum length of the field (or 0)
+     *
+     */
+    constructor(datasource, name, nativeType, fieldParams, maxLength) {
+        super(datasource, name, "string", nativeType, fieldParams, maxLength);
+    }
+}
+exports.OINOStringDataField = OINOStringDataField;
+/**
+ * Specialised class for a boolean column.
+ *
+ */
+class OINOBooleanDataField extends OINODataField {
+    /**
+     * Constructor for a boolean data field
+     *
+     * @param datasource OINO data source reference
+     * @param name name of the field
+     * @param nativeType column type in database
+     * @param fieldParams parameters of the field
+     *
+     */
+    constructor(datasource, name, nativeType, fieldParams) {
+        super(datasource, name, "boolean", nativeType, fieldParams);
+    }
+    /**
+     * Serialize cell value in the given content format.
+     *
+     * @param cellVal cell value
+     *
+     */
+    serializeCell(cellVal) {
+        const parsed_value = (this.datasource.parseValueAsCell(cellVal, this.nativeType) || "").toString();
+        let result;
+        // console.log("OINOBooleanDataField.serializeCell: parsed_value=" + parsed_value)
+        if ((parsed_value == "") || (parsed_value.toLowerCase() == "false") || (parsed_value.match(/^0+$/))) {
+            result = "false";
+        }
+        else {
+            result = "true";
+        }
+        return result;
+    }
+    /**
+     * Parce cell value from string using field type specific formatting rules.
+     *
+     * @param value string value
+     *
+     */
+    deserializeCell(value) {
+        if (value == null || value == "" || value.toString().toLowerCase() == "false" || value == "0") { // TODO: testaa poistaa .toString()
+            return false;
+        }
+        else {
+            return true;
+        }
+    }
+}
+exports.OINOBooleanDataField = OINOBooleanDataField;
+/**
+ * Specialised class for a number column.
+ *
+ */
+class OINONumberDataField extends OINODataField {
+    /**
+     * Constructor for a string data field
+     *
+     * @param datasource OINO data source reference
+     * @param name name of the field
+     * @param nativeType column type in database
+     * @param fieldParams parameters of the field
+     *
+     */
+    constructor(datasource, name, nativeType, fieldParams) {
+        super(datasource, name, "number", nativeType, fieldParams);
+    }
+    /**
+     * Serialize cell value in the given content format.
+     *
+     * @param cellVal cell value
+     *
+     */
+    serializeCell(cellVal) {
+        let result;
+        if ((cellVal === null) || (cellVal === undefined) || (cellVal === "")) {
+            result = null;
+        }
+        else {
+            result = cellVal.toString();
+        }
+        return result;
+    }
+    /**
+     * Parce cell value from string using field type specific formatting rules.
+     *
+     * @param value string value
+     *
+     */
+    deserializeCell(value) {
+        if (value === undefined) {
+            return undefined;
+        }
+        else if ((value === "") || (value === null)) {
+            return null;
+        }
+        else {
+            const result = parseFloat(value);
+            if (isNaN(result)) {
+                OINOLog_js_1.OINOLog.error("@oino-ts/db", "OINONumberDataField", "toSql", "Invalid value!", { value: value });
+                throw new Error(OINOConstants_js_1.OINO_ERROR_PREFIX + ": OINONumberDataField.deserializeCell - Invalid value '" + value + "'"); // incorrectly formatted data could be a security risk, abort processing
+            }
+            return result;
+        }
+    }
+}
+exports.OINONumberDataField = OINONumberDataField;
+/**
+ * Specialised class for a blob column.
+ *
+ */
+class OINOBlobDataField extends OINODataField {
+    /**
+     * Constructor for a blob data field
+     *
+     * @param datasource OINO data source reference
+     * @param name name of the field
+     * @param nativeType column type in database
+     * @param fieldParams parameters of the field
+     * @param maxLength maximum length of the field (or 0)
+     *
+     */
+    constructor(datasource, name, nativeType, fieldParams, maxLength) {
+        super(datasource, name, "blob", nativeType, fieldParams, maxLength);
+    }
+    /**
+     * Serialize cell value in the given content format.
+     *
+     * @param cellVal cell value
+     *
+     */
+    serializeCell(cellVal) {
+        // console.log("OINOBlobDataField.serializeCell: cellVal", cellVal, typeof(cellVal))
+        if ((cellVal === null) || (cellVal === undefined)) {
+            return cellVal;
+        }
+        else if (cellVal instanceof node_buffer_1.Buffer) {
+            return cellVal.toString('base64');
+        }
+        else if (cellVal instanceof Uint8Array) {
+            return node_buffer_1.Buffer.from(cellVal).toString('base64');
+        }
+        else {
+            return this.datasource.parseValueAsCell(cellVal, this.nativeType)?.toString();
+        }
+    }
+    /**
+     * Parce cell value from string using field type specific formatting rules.
+     *
+     * @param value string value
+     *
+     */
+    deserializeCell(value) {
+        if (value == null) {
+            return node_buffer_1.Buffer.alloc(0);
+        }
+        else {
+            return node_buffer_1.Buffer.from(value, 'base64'); // Blob-field data is base64 encoded and converted internally to UInt8Array / Buffer
+        }
+    }
+}
+exports.OINOBlobDataField = OINOBlobDataField;
+/**
+ * Specialised class for a datetime column.
+ *
+ */
+class OINODatetimeDataField extends OINODataField {
+    /**
+     * Constructor for a string data field
+     *
+     * @param datasource OINO data source reference
+     * @param name name of the field
+     * @param nativeType column type in database
+     * @param fieldParams parameters of the field
+     *
+     */
+    constructor(datasource, name, nativeType, fieldParams) {
+        super(datasource, name, "datetime", nativeType, fieldParams);
+    }
+    /**
+     * Serialize cell value in the given content format.
+     *
+     * @param cellVal cell value
+     *
+     */
+    serializeCell(cellVal) {
+        if (typeof (cellVal) == "string") {
+            cellVal = this.datasource.parseValueAsCell(cellVal, this.nativeType);
+        }
+        if ((cellVal === null) || (cellVal === undefined)) {
+            return cellVal;
+        }
+        else if (cellVal instanceof Date) {
+            return cellVal.toISOString();
+        }
+        else {
+            return cellVal.toString();
+        }
+    }
+    /**
+     * Serialize cell value in the given content format.
+     *
+     * @param cellVal cell value
+     * @param locale locale-object to format datetimes with
+     *
+     */
+    serializeCellWithLocale(cellVal, locale) {
+        if (typeof (cellVal) == "string") {
+            cellVal = this.datasource.parseValueAsCell(cellVal, this.nativeType);
+        }
+        if ((cellVal === null) || (cellVal === undefined)) {
+            return cellVal;
+        }
+        else if (cellVal instanceof Date) {
+            return locale.format(cellVal);
+        }
+        else {
+            return cellVal.toString();
+        }
+    }
+    /**
+     * Parce cell value from string using field type specific formatting rules.
+     *
+     * @param value string value
+     *
+     */
+    deserializeCell(value) {
+        if ((value === null) || (value === undefined)) {
+            return value;
+        }
+        else {
+            return new Date(value);
+        }
+    }
+}
+exports.OINODatetimeDataField = OINODatetimeDataField;

package/dist/cjs/OINODataModel.js

@@ -0,0 +1,182 @@
+"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.OINODataModel = void 0;
+const OINODataField_js_1 = require("./OINODataField.js");
+/**
+ * OINO Datamodel object for representing one database table and it's columns.
+ *
+ */
+class OINODataModel {
+    _fieldIndexLookup;
+    /** Database refererence of the table */
+    api;
+    /** Field refererences of the API */
+    fields;
+    /**
+     * Constructor of the data model.
+     * NOTE! OINODbDataModel.initialize must be called after constructor to populate fields.
+     *
+     * @param api api of the data model
+     *
+     */
+    constructor(api) {
+        this._fieldIndexLookup = {};
+        this.api = api;
+        this.fields = [];
+    }
+    /**
+     * Add a field to the datamodel.
+     *
+     * @param field dataset field
+     *
+     */
+    addField(field) {
+        this.fields.push(field);
+        this._fieldIndexLookup[field.name] = this.fields.length - 1;
+    }
+    /**
+     * Find a field of a given name if any.
+     *
+     * @param name name of the field to find
+     *
+     */
+    findFieldByName(name) {
+        const i = this._fieldIndexLookup[name];
+        if (i >= 0) {
+            return this.fields[i];
+        }
+        else {
+            return null;
+        }
+    }
+    /**
+     * Find index of a field of a given name if any.
+     *
+     * @param name name of the field to find
+     *
+     */
+    findFieldIndexByName(name) {
+        const i = this._fieldIndexLookup[name];
+        if (i >= 0) {
+            return i;
+        }
+        else {
+            return -1;
+        }
+    }
+    /**
+     * Find all fields based of given filter callback criteria (e.g. fields of certain data type, primary keys etc.)
+     *
+     * @param filter callback called for each field to include or not
+     *
+     */
+    filterFields(filter) {
+        let result = [];
+        for (let f of this.fields) {
+            if (filter(f)) {
+                result.push(f);
+            }
+        }
+        return result;
+    }
+    /**
+     * Return the primary key values of one row in order of the data model
+     *
+     * @param row data row
+     * @param hashidValues apply hashid when applicable
+     *
+     */
+    getRowPrimarykeyValues(row, hashidValues = false) {
+        let values = [];
+        for (let i = 0; i < this.fields.length; i++) {
+            const f = this.fields[i];
+            if (f.fieldParams.isPrimaryKey) {
+                const value = row[i]?.toString() || "";
+                if (hashidValues && value && (f instanceof OINODataField_js_1.OINONumberDataField) && this.api.hashid) {
+                    values.push(this.api.hashid.encode(value));
+                }
+                else {
+                    values.push(value);
+                }
+            }
+        }
+        return values;
+    }
+    /**
+     * Pring debug information for the field
+     *
+     * @param length length of the debug output (or 0 for as long as needed)
+     *
+     */
+    printColumnDebug(field, length = 0) {
+        let params = "";
+        if (field.fieldParams.isPrimaryKey) {
+            params += "PK ";
+        }
+        if (field.fieldParams.isForeignKey) {
+            params += "FK ";
+        }
+        if (field.fieldParams.isAutoInc) {
+            params += "AUTOINC ";
+        }
+        if (field.fieldParams.isNotNull) {
+            params += "NOTNUL ";
+        }
+        if (params != "") {
+            params = "{" + params.trim() + "}";
+        }
+        if (field.maxLength > 0) {
+            params = field.nativeType + "(" + field.maxLength + ")" + params;
+        }
+        else {
+            params = field.nativeType + params;
+        }
+        const name_length = length - 2 - 1 - params.length;
+        let result = field.name;
+        if (length > 0) {
+            if (result.length > name_length) {
+                result = result.substring(0, name_length - 2) + "..";
+            }
+            result = (result + ":" + params).padEnd(length - 2, " ");
+        }
+        else {
+            result = field.type + ":" + result + ":" + params;
+        }
+        return "[" + result + "]";
+    }
+    /**
+     * Print debug information about the fields.
+     *
+     * @param separator string to separate field prints
+     *
+     */
+    printDebug(separator = "") {
+        let result = this.api.params.tableName + ":" + separator;
+        for (let f of this.fields) {
+            result += this.printColumnDebug(f) + separator;
+        }
+        return result;
+    }
+    /**
+     * Print all public properties (db, table name, fields) of the datamodel. Used
+     * in automated testing validate schema has stayed the same.
+     *
+     */
+    printFieldPublicPropertiesJson() {
+        const result = JSON.stringify(this.fields, (key, value) => {
+            if (key.startsWith("_")) {
+                return undefined;
+            }
+            else {
+                return value;
+            }
+        });
+        return result;
+    }
+}
+exports.OINODataModel = OINODataModel;

package/dist/cjs/OINODataSource.js

@@ -0,0 +1,165 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OINOMemoryDataset = exports.OINODataSet = exports.OINODataSource = void 0;
+const OINOConstants_js_1 = require("./OINOConstants.js");
+const OINOResult_js_1 = require("./OINOResult.js");
+/**
+ * Base class for database abstraction, implementing methods for connecting, making queries and parsing/formatting data
+ * between SQL and serialization formats.
+ *
+ */
+class OINODataSource {
+    isConnected = false;
+    isValidated = false;
+}
+exports.OINODataSource = OINODataSource;
+/**
+ * Base class for SQL results that can be asynchronously iterated (but
+ * not necessarity rewinded). Idea is to handle database specific mechanisms
+ * for returning and formatting conventions in the database specific
+ * implementation. Data might be in memory or streamed in chunks and
+ * `OINODataSet` will serve it out consistently.
+ *
+ */
+class OINODataSet extends OINOResult_js_1.OINOResult {
+    _data;
+    /** Error messages */
+    messages;
+    /**
+     * Constructor for `OINODataSet`.
+     *
+     * @param data internal database specific data type (constructor will throw if invalid)
+     * @param messages error messages from SQL-query
+     *
+     */
+    constructor(data, messages = []) {
+        super();
+        this._data = data;
+        this.messages = messages;
+    }
+    /**
+     * Checks if the messages contain errors.
+     *
+     */
+    hasErrors() {
+        for (let i = 0; i < this.messages.length; i++) {
+            if (this.messages[i].startsWith(OINOConstants_js_1.OINO_ERROR_PREFIX)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Finds the first error message that occured
+     *
+     */
+    getFirstError() {
+        for (let i = this.messages.length - 1; i >= 0; i--) {
+            if (this.messages[i].startsWith(OINOConstants_js_1.OINO_ERROR_PREFIX)) {
+                return this.messages[i];
+            }
+        }
+        return "";
+    }
+    /**
+     * Finds the last error message that occured
+     *
+     */
+    getLastError() {
+        for (let i = 0; i < this.messages.length; i++) {
+            if (this.messages[i].startsWith(OINOConstants_js_1.OINO_ERROR_PREFIX)) {
+                return this.messages[i];
+            }
+        }
+        return "";
+    }
+}
+exports.OINODataSet = OINODataSet;
+/**
+ * Generic in memory implementation of a data set where data is an array of rows. Used
+ * by BunSqlite and automated testing. Can be rewinded.
+ *
+ */
+class OINOMemoryDataset extends OINODataSet {
+    _rows;
+    _currentRow;
+    _eof;
+    /**
+     * Constructor of `OINOMemoryDataset`.
+     *
+     * @param data data as OINODataRow[] (constructor will throw if invalid)
+     * @param errors error messages from SQL-query
+     *
+     */
+    constructor(data, errors = []) {
+        super(data, errors);
+        if ((data == null) || !(Array.isArray(data))) {
+            throw new Error(OINOConstants_js_1.OINO_ERROR_PREFIX + ": Data needs to be compatible with OINORow[]!"); // TODO: maybe check all rows
+        }
+        this._rows = data;
+        if (this.isEmpty()) {
+            this._currentRow = -1;
+            this._eof = true;
+        }
+        else {
+            this._currentRow = 0;
+            this._eof = false;
+        }
+    }
+    /**
+     * Is data set empty.
+     *
+     */
+    isEmpty() {
+        return (this._rows.length == 0);
+    }
+    /**
+     * Is there no more content, i.e. either dataset is empty or we have moved beyond last line
+     *
+     */
+    isEof() {
+        return (this._eof);
+    }
+    /**
+     * Attempts to moves dataset to the next row, possibly waiting for more data to become available. Returns !isEof().
+     *
+     */
+    async next() {
+        if (this._currentRow < this._rows.length - 1) {
+            this._currentRow = this._currentRow + 1;
+        }
+        else {
+            this._eof = true;
+        }
+        return Promise.resolve(!this._eof);
+    }
+    /**
+     * Gets current row of data.
+     *
+     */
+    getRow() {
+        if ((this._currentRow >= 0) && (this._currentRow < this._rows.length)) {
+            return this._rows[this._currentRow];
+        }
+        else {
+            return OINOConstants_js_1.OINO_EMPTY_ROW;
+        }
+    }
+    /**
+     * Gets all rows of data.
+     *
+     */
+    async getAllRows() {
+        return this._rows; // at the moment theres no result streaming, so we can just return the rows
+    }
+    /**
+     * Rewinds data set to the first row, returns !isEof().
+     *
+     */
+    first() {
+        this._currentRow = 0;
+        this._eof = this._rows.length == 0;
+        return !this._eof;
+    }
+}
+exports.OINOMemoryDataset = OINOMemoryDataset;