@oino-ts/db 0.0.11

package/dist/cjs/OINODbDataField.js

@@ -0,0 +1,354 @@
+"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.OINODbDataField = void 0;
+/**
+ * Base class for a column of data responsible for appropriatelly serializing/deserializing the data.
+ *
+ */
+class OINODbDataField {
+    /** OINODB reference*/
+    db;
+    /** Name of the field */
+    name;
+    /** Internal type of field*/
+    type;
+    /** SQL type of the field */
+    sqlType;
+    /** Maximum length of the field (or 0) */
+    maxLength;
+    /** Parameters for the field */
+    fieldParams;
+    /**
+     * Constructor for a data field
+     *
+     * @param db OINODb reference
+     * @param name name of the field
+     * @param type internal type of the field
+     * @param sqlType column type in database
+     * @param fieldParams parameters of the field
+     * @param maxLength maximum length of the field (or 0)
+     *
+     */
+    constructor(db, name, type, sqlType, fieldParams, maxLength = 0) {
+        this.db = db;
+        this.name = name;
+        this.type = type;
+        this.maxLength = maxLength;
+        this.sqlType = sqlType;
+        this.fieldParams = fieldParams;
+        // OINOLog.debug("OINODbDataField.constructor", {this:this})
+    }
+    /**
+     * Pring debug information for the field
+     *
+     * @param length length of the debug output (or 0 for as long as needed)
+     *
+     */
+    printColumnDebug(length = 0) {
+        let params = "";
+        if (this.fieldParams.isPrimaryKey) {
+            params += "PK ";
+        }
+        if (this.fieldParams.isAutoInc) {
+            params += "AUTOINC ";
+        }
+        if (this.fieldParams.isNotNull) {
+            params += "NOTNUL ";
+        }
+        if (params != "") {
+            params = "{" + params.trim() + "}";
+        }
+        if (this.maxLength > 0) {
+            params = this.sqlType + "(" + this.maxLength + ")" + params;
+        }
+        else {
+            params = this.sqlType + params;
+        }
+        const name_length = length - 2 - 1 - params.length;
+        let result = this.name;
+        if (length > 0) {
+            if (result.length > name_length) {
+                result = result.substring(0, name_length - 2) + "..";
+            }
+            result = (result + ":" + params).padEnd(length - 2, " ");
+        }
+        else {
+            result = this.type + ":" + result + ":" + params;
+        }
+        return "[" + result + "]";
+    }
+    /**
+     * Serialize cell value in the given content format.
+     *
+     * @param cellVal cell value
+     *
+     */
+    serializeCell(cellVal) {
+        cellVal = this.db.parseSqlValueAsCell(cellVal, this.sqlType);
+        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
+     *
+     */
+    printCellAsSqlValue(cellVal) {
+        return this.db.printCellAsSqlValue(cellVal, this.sqlType);
+    }
+    /**
+     * Print name of column as SQL.
+     *
+     */
+    printSqlColumnName() {
+        return this.db.printSqlColumnname(this.name);
+    }
+}
+exports.OINODbDataField = OINODbDataField;
+/**
+ * Specialised class for a string column.
+ *
+ */
+class OINOStringDataField extends OINODbDataField {
+    /**
+     * Constructor for a string data field
+     *
+     * @param db OINODb reference
+     * @param name name of the field
+     * @param sqlType column type in database
+     * @param fieldParams parameters of the field
+     * @param maxLength maximum length of the field (or 0)
+     *
+     */
+    constructor(db, name, sqlType, fieldParams, maxLength) {
+        super(db, name, "string", sqlType, fieldParams, maxLength);
+    }
+}
+exports.OINOStringDataField = OINOStringDataField;
+/**
+ * Specialised class for a boolean column.
+ *
+ */
+class OINOBooleanDataField extends OINODbDataField {
+    /**
+     * Constructor for a boolean data field
+     *
+     * @param db OINODb reference
+     * @param name name of the field
+     * @param sqlType column type in database
+     * @param fieldParams parameters of the field
+     *
+     */
+    constructor(db, name, sqlType, fieldParams) {
+        super(db, name, "boolean", sqlType, fieldParams);
+    }
+    /**
+     * Serialize cell value in the given content format.
+     *
+     * @param cellVal cell value
+     *
+     */
+    serializeCell(cellVal) {
+        const parsed_value = (this.db.parseSqlValueAsCell(cellVal, this.sqlType) || "").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 OINODbDataField {
+    /**
+     * Constructor for a string data field
+     *
+     * @param db OINODb reference
+     * @param name name of the field
+     * @param sqlType column type in database
+     * @param fieldParams parameters of the field
+     *
+     */
+    constructor(db, name, sqlType, fieldParams) {
+        super(db, name, "number", sqlType, 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) {
+            return 0;
+        }
+        else {
+            return Number.parseFloat(value);
+        }
+    }
+}
+exports.OINONumberDataField = OINONumberDataField;
+/**
+ * Specialised class for a blob column.
+ *
+ */
+class OINOBlobDataField extends OINODbDataField {
+    /**
+     * Constructor for a blob data field
+     *
+     * @param db OINODb reference
+     * @param name name of the field
+     * @param sqlType column type in database
+     * @param fieldParams parameters of the field
+     * @param maxLength maximum length of the field (or 0)
+     *
+     */
+    constructor(db, name, sqlType, fieldParams, maxLength) {
+        super(db, name, "blob", sqlType, fieldParams, maxLength);
+    }
+    /**
+     * Serialize cell value in the given content format.
+     *
+     * @param cellVal cell value
+     *
+     */
+    serializeCell(cellVal) {
+        // OINOLog.debug("OINOBlobDataField.serializeCell", {cellVal:cellVal})
+        if ((cellVal === null) || (cellVal === undefined)) {
+            return cellVal;
+        }
+        else if (cellVal instanceof Uint8Array) {
+            return Buffer.from(cellVal).toString('base64');
+        }
+        else {
+            return cellVal.toString();
+        }
+    }
+    /**
+     * Parce cell value from string using field type specific formatting rules.
+     *
+     * @param value string value
+     *
+     */
+    deserializeCell(value) {
+        if (value == null) {
+            return new Buffer(0);
+        }
+        else {
+            return 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 OINODbDataField {
+    /**
+     * Constructor for a string data field
+     *
+     * @param db OINODb reference
+     * @param name name of the field
+     * @param sqlType column type in database
+     * @param fieldParams parameters of the field
+     *
+     */
+    constructor(db, name, sqlType, fieldParams) {
+        super(db, name, "datetime", sqlType, fieldParams);
+    }
+    /**
+     * Serialize cell value in the given content format.
+     *
+     * @param cellVal cell value
+     *
+     */
+    serializeCell(cellVal) {
+        // OINOLog.debug("OINODatetimeDataField.serializeCell", {cellVal:cellVal, type:typeof(cellVal)})
+        if (typeof (cellVal) == "string") {
+            cellVal = this.db.parseSqlValueAsCell(cellVal, this.sqlType);
+            // OINOLog.debug("OINODatetimeDataField.serializeCell parsed", {cellVal:cellVal, type:typeof(cellVal)})
+        }
+        if ((cellVal === null) || (cellVal === undefined)) {
+            return cellVal;
+        }
+        else if (cellVal instanceof Date) {
+            return cellVal.toISOString();
+        }
+        else {
+            return cellVal.toString();
+        }
+    }
+    /**
+     * Parce cell value from string using field type specific formatting rules.
+     *
+     * @param value string value
+     *
+     */
+    deserializeCell(value) {
+        // OINOLog.debug("OINODatetimeDataField.deserializeCell", {strVal:strVal})
+        if ((value === null) || (value === undefined)) {
+            return value;
+        }
+        else {
+            return new Date(value);
+        }
+    }
+}
+exports.OINODatetimeDataField = OINODatetimeDataField;

package/dist/cjs/OINODbDataModel.js

@@ -0,0 +1,279 @@
+"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.OINODbDataModel = void 0;
+const index_js_1 = require("./index.js");
+/**
+ * OINO Datamodel object for representing one database table and it's columns.
+ *
+ */
+class OINODbDataModel {
+    _columnLookup;
+    /** 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._columnLookup = {};
+        this.api = api;
+        this.fields = [];
+        // OINOLog_debug("OINODbDataModel (" + tableName + "):\n" + this._printTableDebug("\n"))
+    }
+    /**
+     * Initialize datamodel from SQL schema.
+     *
+     */
+    async initialize() {
+        await this.api.db.initializeApiDatamodel(this.api);
+    }
+    _printSqlColumnNames() {
+        let result = "";
+        for (let f of this.fields) {
+            if (result != "") {
+                result += ",";
+            }
+            result += f.printSqlColumnName();
+        }
+        return result;
+    }
+    _printSqlInsertColumnsAndValues(row) {
+        let columns = "";
+        let values = "";
+        for (let i = 0; i < this.fields.length; i++) {
+            const val = row[i];
+            // console.log("_printSqlInsertColumnsAndValues: row[" + i + "]=" + val)
+            if (val !== undefined) {
+                const f = this.fields[i];
+                if (values != "") {
+                    columns += ",";
+                    values += ",";
+                }
+                columns += f.printSqlColumnName();
+                values += f.printCellAsSqlValue(val);
+            }
+        }
+        // console.log("_printSqlInsertColumnsAndValues: columns=" + columns + ", values=" + values)
+        return "(" + columns + ") VALUES (" + values + ")";
+    }
+    _printSqlUpdateValues(row) {
+        let result = "";
+        for (let i = 0; i < this.fields.length; i++) {
+            const f = this.fields[i];
+            const val = row[i];
+            // OINOLog_debug("OINODbDataModel._printSqlUpdateValues", {field:f.name, primary_key:f.fieldParams.isPrimaryKey, val:val})
+            if ((!f.fieldParams.isPrimaryKey) && (val !== undefined)) {
+                if (result != "") {
+                    result += ",";
+                }
+                result += f.printSqlColumnName() + "=" + f.printCellAsSqlValue(val);
+            }
+        }
+        return result;
+    }
+    _printSqlPrimaryKeyCondition(id_value) {
+        let result = "";
+        let i = 0;
+        const id_parts = id_value.split(index_js_1.OINODbConfig.OINODB_ID_SEPARATOR);
+        for (let f of this.fields) {
+            if (f.fieldParams.isPrimaryKey) {
+                if (result != "") {
+                    result += " AND ";
+                }
+                let value = decodeURIComponent(id_parts[i]);
+                if ((f instanceof index_js_1.OINONumberDataField) && (this.api.hashid)) {
+                    value = this.api.hashid.decode(value);
+                }
+                result += f.printSqlColumnName() + "=" + f.printCellAsSqlValue(value);
+                i = i + 1;
+            }
+        }
+        if (i != id_parts.length) {
+            throw new Error(index_js_1.OINO_ERROR_PREFIX + ": id '" + id_value + "' is not a valid key for table " + this.api.params.tableName);
+        }
+        return "(" + result + ")";
+    }
+    /**
+     * Add a field to the datamodel.
+     *
+     * @param field dataset field
+     *
+     */
+    addField(field) {
+        this.fields.push(field);
+        this._columnLookup[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) {
+        // OINOLog.debug("OINODbDataModel.findFieldByName", {_columnLookup:this._columnLookup})
+        const i = this._columnLookup[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) {
+        // OINOLog.debug("OINODbDataModel.findFieldIndexByName", {_columnLookup:this._columnLookup})
+        const i = this._columnLookup[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 index_js_1.OINONumberDataField) && this.api.hashid) {
+                    values.push(this.api.hashid.encode(value));
+                }
+                else {
+                    values.push(value);
+                }
+            }
+        }
+        return values;
+    }
+    /**
+     * 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 += f.printColumnDebug() + 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;
+    }
+    /**
+     * Print SQL select statement using optional id and filter.
+     *
+     * @param id OINO ID (i.e. combined primary key values)
+     * @param params OINO reqest params
+     *
+     */
+    printSqlSelect(id, params) {
+        let result = "SELECT " + this._printSqlColumnNames() + " FROM " + this.api.db.printSqlTablename(this.api.params.tableName);
+        const filter_sql = params.filter?.toSql(this) || "";
+        const order_sql = params.order?.toSql(this) || "";
+        const limit_sql = params.limit?.toSql(this) || "";
+        // OINOLog.debug("OINODbDataModel.printSqlSelect", {select_sql:result, filter_sql:filter_sql, order_sql:order_sql})
+        if ((id != "") && (filter_sql != "")) {
+            result += "\nWHERE " + this._printSqlPrimaryKeyCondition(id) + " AND " + filter_sql;
+        }
+        else if (id != "") {
+            result += "\nWHERE " + this._printSqlPrimaryKeyCondition(id);
+        }
+        else if (filter_sql != "") {
+            result += "\nWHERE " + filter_sql;
+        }
+        if (order_sql) {
+            result += "\nORDER BY " + order_sql;
+        }
+        if (limit_sql) {
+            result += "\nLIMIT " + limit_sql;
+        }
+        result += ";";
+        index_js_1.OINOLog.debug("OINODbDataModel.printSqlSelect", { result: result });
+        return result;
+    }
+    /**
+     * Print SQL insert statement from one data row.
+     *
+     * @param row one row of data in the data model
+     *
+     */
+    printSqlInsert(row) {
+        let result = "INSERT INTO " + this.api.db.printSqlTablename(this.api.params.tableName) + " " + this._printSqlInsertColumnsAndValues(row) + ";";
+        return result;
+    }
+    /**
+     * Print SQL insert statement from one data row.
+     *
+     * @param id OINO ID (i.e. combined primary key values)
+     * @param row one row of data in the data model
+     *
+     */
+    printSqlUpdate(id, row) {
+        let result = "UPDATE " + this.api.db.printSqlTablename(this.api.params.tableName) + " SET " + this._printSqlUpdateValues(row) + " WHERE " + this._printSqlPrimaryKeyCondition(id) + ";";
+        return result;
+    }
+    /**
+     * Print SQL delete statement for id.
+     *
+     * @param id OINO ID (i.e. combined primary key values)
+     *
+     */
+    printSqlDelete(id) {
+        let result = "DELETE FROM " + this.api.db.printSqlTablename(this.api.params.tableName) + " WHERE " + this._printSqlPrimaryKeyCondition(id) + ";";
+        return result;
+    }
+}
+exports.OINODbDataModel = OINODbDataModel;