@oino-ts/db 0.0.11

package/dist/esm/OINODbDataModel.js

@@ -0,0 +1,275 @@
+/*
+ * 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/.
+ */
+import { OINO_ERROR_PREFIX, OINODbConfig, OINONumberDataField, OINOLog } from "./index.js";
+/**
+ * OINO Datamodel object for representing one database table and it's columns.
+ *
+ */
+export 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(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 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(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 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 += ";";
+        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;
+    }
+}

package/dist/esm/OINODbDataSet.js

@@ -0,0 +1,134 @@
+/*
+ * 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/.
+ */
+import { OINO_ERROR_PREFIX, OINODB_EMPTY_ROW } from "./index.js";
+/**
+ * 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
+ * `OINODbDataSet` will serve it out consistently.
+ *
+ */
+export class OINODbDataSet {
+    _data;
+    /** Error messages */
+    messages;
+    /**
+     * Constructor for `OINODbDataSet`.
+     *
+     * @param data internal database specific data type (constructor will throw if invalid)
+     * @param messages error messages from SQL-query
+     *
+     */
+    constructor(data, messages = []) {
+        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(OINO_ERROR_PREFIX)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Checks if the messages contain errors.
+     *
+     */
+    getFirstError() {
+        for (let i = 0; i < this.messages.length; i++) {
+            if (this.messages[i].startsWith(OINO_ERROR_PREFIX)) {
+                return this.messages[i];
+            }
+        }
+        return "";
+    }
+}
+/**
+ * Generic in memory implementation of a data set where data is an array of rows. Used
+ * by BunSqlite and automated testing. Can be rewinded.
+ *
+ */
+export class OINODbMemoryDataSet extends OINODbDataSet {
+    _rows;
+    _currentRow;
+    _eof;
+    /**
+     * Constructor of `OINODbMemoryDataSet`.
+     *
+     * @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(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);
+    }
+    /**
+     * Moves dataset to the next row, returns !isEof().
+     *
+     */
+    next() {
+        if (this._currentRow < this._rows.length - 1) {
+            this._currentRow = this._currentRow + 1;
+        }
+        else {
+            this._eof = true;
+        }
+        return !this._eof;
+    }
+    /**
+     * Gets current row of data.
+     *
+     */
+    getRow() {
+        if ((this._currentRow >= 0) && (this._currentRow < this._rows.length)) {
+            return this._rows[this._currentRow];
+        }
+        else {
+            return OINODB_EMPTY_ROW;
+        }
+    }
+    /**
+     * Rewinds data set to the first row, returns !isEof().
+     *
+     */
+    first() {
+        this._currentRow = 0;
+        this._eof = this._rows.length == 0;
+        return !this._eof;
+    }
+}