@oino-ts/db 0.21.2 → 1.0.1

package/dist/esm/OINODbDataModel.js

@@ -3,16 +3,16 @@
  * 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 } from "@oino-ts/common";
-import { OINODbConfig, OINONumberDataField, OINODB_UNDEFINED } from "./index.js";
+import { OINO_ERROR_PREFIX, OINODataModel, OINOConfig, OINONumberDataField } from "@oino-ts/common";
+import { OINODB_UNDEFINED } from "./OINODbConstants.js";
+import { OINODbQueryOrder, OINODbQueryFilter, OINODbQueryLimit, OINODbQueryAggregate } from "./OINODbQueryParams.js";
 /**
  * OINO Datamodel object for representing one database table and it's columns.
  *
  */
-export class OINODbDataModel {
-    _fieldIndexLookup;
+export class OINODbDataModel extends OINODataModel {
     /** Database refererence of the table */
-    api;
+    dbApi;
     /** Field refererences of the API */
     fields;
     /**
@@ -23,26 +23,19 @@ export class OINODbDataModel {
      *
      */
     constructor(api) {
-        this._fieldIndexLookup = {};
-        this.api = api;
+        super(api);
+        this.dbApi = api;
         this.fields = [];
     }
-    /**
-     * Initialize datamodel from SQL schema.
-     *
-     */
-    async initialize() {
-        await this.api.db.initializeApiDatamodel(this.api);
-    }
-    _printSqlColumnNames(select) {
+    _printColumnNames(select) {
         let result = "";
         for (let i = 0; i < this.fields.length; i++) {
             const f = this.fields[i];
-            if (select?.isSelected(f) === false) { // if a field is not selected, we include a constant and correct fieldname instead so that dimensions of the data don't change but no unnecessary data is fetched
-                result += f.db.printSqlString(OINODB_UNDEFINED) + " as " + f.printSqlColumnName() + ",";
+            if ((select?.isSelected(f.name) === false) && (f.fieldParams.isPrimaryKey == false)) { // if a field is not selected, we include a constant and correct fieldname instead so that dimensions of the data don't change but no unnecessary data is fetched
+                result += f.datasource.printStringValue(OINODB_UNDEFINED) + " as " + f.printColumnName() + ",";
             }
             else {
-                result += f.printSqlColumnName() + ",";
+                result += f.printColumnName() + ",";
             }
         }
         return result.substring(0, result.length - 1);
@@ -59,8 +52,8 @@ export class OINODbDataModel {
                     columns += ",";
                     values += ",";
                 }
-                columns += f.printSqlColumnName();
-                values += f.printCellAsSqlValue(val);
+                columns += f.printColumnName();
+                values += f.printCellAsValue(val);
             }
         }
         // console.log("_printSqlInsertColumnsAndValues: columns=" + columns + ", values=" + values)
@@ -75,7 +68,7 @@ export class OINODbDataModel {
                 if (result != "") {
                     result += ",";
                 }
-                result += f.printSqlColumnName() + "=" + f.printCellAsSqlValue(val);
+                result += f.printColumnName() + "=" + f.printCellAsValue(val);
             }
         }
         if (result == "") {
@@ -86,21 +79,21 @@ export class OINODbDataModel {
     _printSqlPrimaryKeyCondition(id_value) {
         let result = "";
         let i = 0;
-        const id_parts = id_value.split(OINODbConfig.OINODB_ID_SEPARATOR);
+        const id_parts = id_value.split(OINOConfig.OINO_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);
+                if ((f instanceof OINONumberDataField) && (this.dbApi.hashid)) {
+                    value = this.dbApi.hashid.decode(value);
                 }
-                value = f.printCellAsSqlValue(value);
+                value = f.printCellAsValue(value);
                 if (value == "") { // ids are user input and could be specially crafted to be empty
                     throw new Error(OINO_ERROR_PREFIX + ": empty condition for id '" + id_value + "' for table " + this.api.params.tableName);
                 }
-                result += f.printSqlColumnName() + "=" + value;
+                result += f.printColumnName() + "=" + value;
                 i = i + 1;
             }
         }
@@ -113,118 +106,11 @@ export class OINODbDataModel {
         let result = [];
         for (let f of this.fields) {
             if (f.fieldParams.isPrimaryKey) {
-                result.push(this.api.db.printSqlColumnname(f.name));
+                result.push(this.dbApi.db.printColumnName(f.name));
             }
         }
         return result;
     }
-    /**
-     * 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 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.
      *
@@ -235,15 +121,15 @@ export class OINODbDataModel {
     printSqlSelect(id, params) {
         let column_names = "";
         if (params.aggregate) {
-            column_names = params.aggregate.printSqlColumnNames(this, params.select);
+            column_names = OINODbQueryAggregate.printColumnNames(params.aggregate, this, params.select);
         }
         else {
-            column_names = this._printSqlColumnNames(params.select);
+            column_names = this._printColumnNames(params.select);
         }
-        const order_sql = params.order?.toSql(this) || "";
-        const limit_sql = params.limit?.toSql(this) || "";
-        const filter_sql = params.filter?.toSql(this) || "";
-        const groupby_sql = params.aggregate?.toSql(this, params.select) || "";
+        const order_sql = params.order ? OINODbQueryOrder.printSql(params.order, this) : "";
+        const limit_sql = params.limit ? OINODbQueryLimit.printSql(params.limit, this) : "";
+        const filter_sql = params.filter ? OINODbQueryFilter.printSql(params.filter, this) : "";
+        const groupby_sql = params.aggregate ? OINODbQueryAggregate.printSql(params.aggregate, this, params.select) : "";
         let where_sql = "";
         if ((id != null) && (id != "") && (filter_sql != "")) {
             where_sql = this._printSqlPrimaryKeyCondition(id) + " AND " + filter_sql;
@@ -254,7 +140,7 @@ export class OINODbDataModel {
         else if (filter_sql != "") {
             where_sql = filter_sql;
         }
-        const result = this.api.db.printSqlSelect(this.api.params.tableName, column_names, where_sql, order_sql, limit_sql, groupby_sql);
+        const result = this.dbApi.db.printSqlSelect(this.api.params.tableName, column_names, where_sql, order_sql, limit_sql, groupby_sql);
         return result;
     }
     /**
@@ -264,10 +150,10 @@ export class OINODbDataModel {
      *
      */
     printSqlInsert(row) {
-        const table_name = this.api.db.printSqlTablename(this.api.params.tableName);
+        const table_name = this.dbApi.db.printTableName(this.api.params.tableName);
         const [columns, values] = this._printSqlInsertColumnsAndValues(row);
         const return_fields = this.api.params.returnInsertedIds ? this._printSqlPrimaryKeyColumns() : undefined;
-        return this.api.db.printSqlInsert(table_name, columns, values, return_fields);
+        return this.dbApi.db.printSqlInsert(table_name, columns, values, return_fields);
     }
     /**
      * Print SQL insert statement from one data row.
@@ -277,7 +163,7 @@ export class OINODbDataModel {
      *
      */
     printSqlUpdate(id, row) {
-        let result = "UPDATE " + this.api.db.printSqlTablename(this.api.params.tableName) + " SET " + this._printSqlUpdateValues(row) + " WHERE " + this._printSqlPrimaryKeyCondition(id) + ";";
+        let result = "UPDATE " + this.dbApi.db.printTableName(this.api.params.tableName) + " SET " + this._printSqlUpdateValues(row) + " WHERE " + this._printSqlPrimaryKeyCondition(id) + ";";
         return result;
     }
     /**
@@ -287,7 +173,7 @@ export class OINODbDataModel {
      *
      */
     printSqlDelete(id) {
-        let result = "DELETE FROM " + this.api.db.printSqlTablename(this.api.params.tableName) + " WHERE " + this._printSqlPrimaryKeyCondition(id) + ";";
+        let result = "DELETE FROM " + this.dbApi.db.printTableName(this.api.params.tableName) + " WHERE " + this._printSqlPrimaryKeyCondition(id) + ";";
         return result;
     }
 }

package/dist/esm/OINODbFactory.js

@@ -3,7 +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 { OINODbApi } from "./index.js";
+import { OINODbApi } from "./OINODbApi.js";
 /**
  * Static factory class for easily creating things based on data
  *

package/dist/esm/OINODbQueryParams.js

@@ -0,0 +1,194 @@
+/*
+ * 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, OINOLog, OINOQueryNullCheck, OINOQueryFilter, OINOQueryOrder, OINOQueryLimit, OINOQueryAggregate, OINOQueryAggregateFunctions } from "@oino-ts/common";
+/**
+ * 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).
+ *
+ */
+export class OINODbQueryFilter extends OINOQueryFilter {
+    static operatorToSql(filter) {
+        switch (filter.operator) {
+            case "and": return " AND ";
+            case "or": return " OR ";
+            case "not": return "NOT ";
+            case "lt": return " < ";
+            case "le": return " <= ";
+            case "eq": return " = ";
+            case "ne": return " != ";
+            case "ge": return " >= ";
+            case "gt": return " > ";
+            case "like": return " LIKE ";
+            case "isnull": return " IS NULL";
+            case "isNotNull": return " IS NOT NULL";
+        }
+        return " ";
+    }
+    /**
+     * Print filter as SQL condition based on the datamodel of the API.
+     *
+     * @param dataModel data model (and database) to use for formatting of values
+     *
+     */
+    static printSql(filter, dataModel) {
+        if (filter.isEmpty()) {
+            return "";
+        }
+        let result = "";
+        let field = null;
+        if (filter.leftSide instanceof OINOQueryFilter) {
+            result += OINODbQueryFilter.printSql(filter.leftSide, dataModel);
+        }
+        else {
+            field = dataModel.findFieldByName(filter.leftSide);
+            if (!field) {
+                OINOLog.error("@oino-ts/db", "OINODbQueryFilter", "toSql", "Invalid field!", { field: filter.leftSide });
+                throw new Error(OINO_ERROR_PREFIX + ": OINODbQueryFilter.toSql - Invalid field '" + filter.leftSide + "'"); // invalid field name could be a security risk, stop processing
+            }
+            result += dataModel.api.datasource.printColumnName(field.name);
+        }
+        result += OINODbQueryFilter.operatorToSql(filter);
+        if (filter.rightSide instanceof OINOQueryFilter) {
+            result += OINODbQueryFilter.printSql(filter.rightSide, dataModel);
+        }
+        else if (filter.operator == OINOQueryNullCheck.isnull || filter.operator == OINOQueryNullCheck.isNotNull) {
+            // nothing to do, IS NULL and IS NOT NULL do not have a right side
+        }
+        else {
+            const value = field.deserializeCell(filter.rightSide);
+            if ((value == null) || (value === "")) {
+                OINOLog.error("@oino-ts/db", "OINODbQueryFilter", "toSql", "Invalid value!", { value: value });
+                throw new Error(OINO_ERROR_PREFIX + ": OINODbQueryFilter.toSql - Invalid value '" + value + "'"); // invalid value could be a security risk, stop processing
+            }
+            result += field.printCellAsValue(value);
+        }
+        result = "(" + result + ")";
+        OINOLog.debug("@oino-ts/db", "OINODbQueryFilter", "toSql", "Result", { sql: result });
+        return result;
+    }
+}
+/**
+ * Class for ordering select results on a number of columns.
+ *
+ */
+export class OINODbQueryOrder extends OINOQueryOrder {
+    /**
+     * Print order as SQL condition based on the datamodel of the API.
+     *
+     * @param order order instance
+     * @param dataModel data model (and database) to use for formatting of values
+     *
+     */
+    static printSql(order, dataModel) {
+        if (order.isEmpty()) {
+            return "";
+        }
+        let result = "";
+        for (let i = 0; i < order.columns.length; i++) {
+            const field = dataModel.findFieldByName(order.columns[i]);
+            if (!field) {
+                OINOLog.error("@oino-ts/db", "OINODbQueryOrder", "toSql", "Invalid field!", { field: order.columns[i] });
+                throw new Error(OINO_ERROR_PREFIX + ": OINODbQueryOrder.toSql - Invalid field '" + order.columns[i] + "'"); // invalid field name could be a security risk, stop processing
+            }
+            if (result) {
+                result += ",";
+            }
+            result += dataModel.api.datasource.printColumnName(field.name) + " ";
+            if (order.descending[i]) {
+                result += "DESC";
+            }
+            else {
+                result += "ASC";
+            }
+        }
+        OINOLog.debug("@oino-ts/db", "OINODbQueryOrder", "toSql", "Result", { sql: result });
+        return result;
+    }
+}
+/**
+ * Class for limiting the number of results.
+ *
+ */
+export class OINODbQueryLimit extends OINOQueryLimit {
+    /**
+     * Print order as SQL condition based on the datamodel of the API.
+     *
+     * @param limit limit instance
+     * @param dataModel data model (and database) to use for formatting of values
+     *
+     */
+    static printSql(limit, dataModel) {
+        if (limit.isEmpty()) {
+            return "";
+        }
+        let result = limit.limit.toString();
+        if (limit.page > 0) {
+            result += " OFFSET " + (limit.limit * (limit.page - 1) + 1).toString();
+        }
+        OINOLog.debug("@oino-ts/db", "OINODbQueryLimit", "toSql", "Result", { sql: result });
+        return result;
+    }
+}
+/**
+ * Class for limiting the number of results.
+ *
+ */
+export class OINODbQueryAggregate extends OINOQueryAggregate {
+    /**
+     * Print non-aggregated fields as SQL GROUP BY-condition based on the datamodel of the API.
+     *
+     * @param aggregate aggregate instance
+     * @param dataModel data model (and database) to use for formatting of values
+     * @param select what fields to select
+     *
+     */
+    static printSql(aggregate, dataModel, select) {
+        if (aggregate.isEmpty()) {
+            return "";
+        }
+        let result = "";
+        for (let i = 0; i < dataModel.fields.length; i++) {
+            const f = dataModel.fields[i];
+            if ((select?.isSelected(f.name) || (f.fieldParams.isPrimaryKey == true)) && (aggregate.fields.includes(f.name) == false)) {
+                result += f.printColumnName() + ",";
+            }
+        }
+        result = result.substring(0, result.length - 1);
+        OINOLog.debug("@oino-ts/db", "OINODbQueryAggregate", "toSql", "Result", { sql: result });
+        return result;
+    }
+    /**
+     * Print non-aggregated fields as SQL GROUP BY-condition based on the datamodel of the API.
+     *
+     * @param dataModel data model (and database) to use for formatting of values
+     * @param select what fields to select
+     *
+     */
+    static printColumnNames(aggregate, dataModel, select) {
+        let result = "";
+        for (let i = 0; i < dataModel.fields.length; i++) {
+            const f = dataModel.fields[i];
+            if ((select?.isSelected(f.name) === false) && (f.fieldParams.isPrimaryKey == false)) { // if a field is not selected, we include an aggregated constant (min of const string) and correct fieldname instead so that dimensions of the data don't change, it does not need a group by but no unnecessary data is fetched
+                result += OINOQueryAggregateFunctions.min + "(" + f.datasource.printStringValue("") + ") as " + f.printColumnName() + ",";
+            }
+            else {
+                const aggregate_index = aggregate.fields.indexOf(f.name);
+                const col_name = f.printColumnName();
+                if (aggregate_index >= 0) {
+                    result += aggregate.functions[aggregate_index] + "(" + col_name + ") as " + col_name + ",";
+                }
+                else {
+                    result += col_name + ",";
+                }
+            }
+        }
+        return result.substring(0, result.length - 1);
+    }
+}

package/dist/esm/index.js

@@ -1,16 +1,6 @@
-export { OINODbApiResult, OINODbHtmlTemplate, OINODbApi, OINODbApiRequest } from "./OINODbApi.js";
+export { OINODb } from "./OINODb.js";
 export { OINODbDataModel } from "./OINODbDataModel.js";
-export { OINODbModelSet } from "./OINODbModelSet.js";
-export { OINODbDataField, OINOBooleanDataField, OINONumberDataField, OINOStringDataField, OINOBlobDataField, OINODatetimeDataField } from "./OINODbDataField.js";
-export { OINODbDataSet, OINODbMemoryDataSet, OINODb } from "./OINODb.js";
-export { OINODbSqlFilter, OINODbSqlOrder, OINODbSqlComparison, OINODbSqlLimit, OINODbSqlBooleanOperation, OINODbSqlAggregate, OINODbSqlAggregateFunctions, OINODbSqlSelect, OINODbSqlNullCheck } from "./OINODbSqlParams.js";
-export { OINODbConfig } from "./OINODbConfig.js";
 export { OINODbFactory } from "./OINODbFactory.js";
-export { OINODbSwagger } from "./OINODbSwagger.js";
-export { OINODbParser } from "./OINODbParser.js";
-/** Empty row instance */
-export const OINODB_EMPTY_ROW = [];
-/** Empty row array instance */
-export const OINODB_EMPTY_ROWS = [];
-/** Constant for undefined values */
-export const OINODB_UNDEFINED = ""; // original idea was to have a defined literal that get's swapped back to undefined, but current implementation just leaves it out at serialization (so value does not matter)
+export { OINODbApi } from "./OINODbApi.js";
+export { OINODbQueryFilter, OINODbQueryOrder, OINODbQueryLimit, OINODbQueryAggregate } from "./OINODbQueryParams.js";
+export { OINODB_UNDEFINED } from "./OINODbConstants.js";