@oino-ts/db 0.0.11

package/src/OINODbDataModel.ts

@@ -0,0 +1,290 @@
+/*
+ * 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 { OINODbDataField, OINODbApi, OINODataRow, OINO_ERROR_PREFIX, OINODbDataFieldFilter, OINODbConfig, OINODbSqlParams, OINONumberDataField, OINOLog } from "./index.js";
+
+/**
+ * OINO Datamodel object for representing one database table and it's columns.
+ *
+ */
+export class OINODbDataModel {
+    private _columnLookup:Record<string, number>;
+
+    /** Database refererence of the table */
+    readonly api:OINODbApi 
+
+    /** Field refererences of the API */
+    readonly fields: OINODbDataField[]
+
+    /**
+     * 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:OINODbApi) {
+        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)
+    }
+
+    private _printSqlColumnNames(): string {
+        let result: string = "";
+        for (let f of this.fields) {
+            if (result != "") {
+                result += ",";
+            }
+            result += f.printSqlColumnName();
+        }
+        return result;
+    }
+
+    private _printSqlInsertColumnsAndValues(row: OINODataRow): string {
+        let columns: string = "";
+        let values: string = "";
+        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 + ")";
+    }
+
+    private _printSqlUpdateValues(row: OINODataRow): string {
+        let result: string = "";
+        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;
+    }
+
+    private _printSqlPrimaryKeyCondition(id_value: string): string {
+        let result: string = ""
+        let i:number = 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:OINODbDataField) {
+        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:string):OINODbDataField|null {
+        // OINOLog.debug("OINODbDataModel.findFieldByName", {_columnLookup:this._columnLookup})
+        const i:number = 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:string):number {
+        // OINOLog.debug("OINODbDataModel.findFieldIndexByName", {_columnLookup:this._columnLookup})
+        const i:number = 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:OINODbDataFieldFilter):OINODbDataField[] {
+        let result:OINODbDataField[] = []
+        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: OINODataRow, hashidValues:boolean = false): string[] {
+        let values: string[] = [];
+        for (let i=0; i< this.fields.length; i++) {
+            const f = this.fields[i]
+            if (f.fieldParams.isPrimaryKey) {
+                const value:string = 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:string = ""): string {
+        let result: string = 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():string {
+        const result:string = JSON.stringify(this.fields, (key:any, value:any) => { 
+            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: string, params:OINODbSqlParams): string {
+        let result:string = "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: OINODataRow): string {
+        let result: string = "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: string, row: OINODataRow): string {
+        let result: string = "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: string): string {
+        let result: string = "DELETE FROM " + this.api.db.printSqlTablename(this.api.params.tableName) + " WHERE " + this._printSqlPrimaryKeyCondition(id) + ";";
+        return result;
+    }
+}

package/src/OINODbDataSet.ts

@@ -0,0 +1,170 @@
+/*
+ * 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 { OINODataRow, 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 abstract class OINODbDataSet {
+    private _data: unknown;
+
+    /** Error messages */
+    readonly messages: string[];
+
+    /**
+     * Constructor for `OINODbDataSet`.
+     *
+     * @param data internal database specific data type (constructor will throw if invalid)
+     * @param messages error messages from SQL-query
+     * 
+     */
+    constructor(data: unknown, messages: string[] = []) {
+        this._data = data;
+        this.messages = messages;
+    }
+
+    /**
+     * Is data set empty.
+     *
+     */
+    abstract isEmpty(): boolean;
+
+    /**
+     * Is there no more content, i.e. either dataset is empty or we have moved beyond last line
+     *
+     */
+    abstract isEof(): boolean;
+
+    /**
+     * Moves dataset to the next row, returns !isEof().
+     *
+     */
+    abstract next(): boolean;
+
+    /**
+     * Gets current row of data.
+     *
+     */
+    abstract getRow(): OINODataRow;
+
+    /**
+     * Checks if the messages contain errors.
+     * 
+     */
+    hasErrors(): boolean {
+        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(): string {
+        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 {
+    private _rows: OINODataRow[];
+    private _currentRow: number;
+    private _eof: boolean;
+
+    /**
+     * Constructor of `OINODbMemoryDataSet`.
+     * 
+     * @param data data as OINODataRow[] (constructor will throw if invalid)
+     * @param errors error messages from SQL-query
+     *
+     */
+    constructor(data: unknown, errors: string[] = []) {
+        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 as OINODataRow[];
+        if (this.isEmpty()) {
+            this._currentRow = -1;
+            this._eof = true;
+        } else {
+            this._currentRow = 0;
+            this._eof = false;
+        }
+    }
+
+
+
+
+   /**
+     * Is data set empty.
+     *
+     */
+    isEmpty(): boolean {
+        return (this._rows.length == 0);
+    }
+
+    /**
+     * Is there no more content, i.e. either dataset is empty or we have moved beyond last line
+     *
+     */
+    isEof(): boolean {
+        return (this._eof);
+    }
+
+    /**
+     * Moves dataset to the next row, returns !isEof().
+     *
+     */
+    next(): boolean {
+        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(): OINODataRow {
+        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(): boolean {
+        this._currentRow = 0;
+        this._eof = this._rows.length == 0;
+        return !this._eof;
+    }
+}