@oino-ts/common 0.21.2 → 1.0.0

package/dist/esm/OINODataSource.js

@@ -0,0 +1,159 @@
+import { OINO_EMPTY_ROW, OINO_ERROR_PREFIX } from "./OINOConstants.js";
+import { OINOResult } from "./OINOResult.js";
+/**
+ * Base class for database abstraction, implementing methods for connecting, making queries and parsing/formatting data
+ * between SQL and serialization formats.
+ *
+ */
+export class OINODataSource {
+    isConnected = false;
+    isValidated = false;
+}
+/**
+ * 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.
+ *
+ */
+export class OINODataSet extends 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(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(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(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 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(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 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;
+    }
+}

package/dist/esm/OINOFormatter.js

@@ -3,7 +3,8 @@
  * 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 } from "./index.js";
+import { OINO_ERROR_PREFIX } from "./OINOConstants.js";
+import { OINOLog } from "./OINOLog.js";
 /**
  * Class for formatting strings and values.
  *

package/dist/esm/OINOHtmlTemplate.js

@@ -1,4 +1,7 @@
-import { OINOStr, OINOContentType, OINOHttpResult, OINO_ERROR_PREFIX, OINO_WARNING_PREFIX, OINO_INFO_PREFIX, OINO_DEBUG_PREFIX, OINOBenchmark } from ".";
+import { OINOContentType, OINO_ERROR_PREFIX, OINO_WARNING_PREFIX, OINO_INFO_PREFIX, OINO_DEBUG_PREFIX } from "./OINOConstants.js";
+import { OINOStr } from "./OINOStr.js";
+import { OINOHttpResult } from "./OINOResult.js";
+import { OINOBenchmark } from "./OINOBenchmark.js";
 import { OINO_EMPTY_FORMATTER, OINOFormatter } from "./OINOFormatter";
 /**
  * Class for rendering HTML from data.

package/dist/esm/OINOModelSet.js

@@ -0,0 +1,329 @@
+/*
+ * 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 { OINOContentType } from "./OINOConstants.js";
+import { OINOConfig } from "./OINOConfig.js";
+import { OINOStr } from "./OINOStr.js";
+import { OINOLog } from "./OINOLog.js";
+import { OINOBlobDataField, OINONumberDataField, OINOBooleanDataField } from "./OINODataField.js";
+/**
+ * Class for dataset based on a data model that can be serialized to
+ * a supported format:
+ * - JSON (application/json)
+ * - CSV (text/csv)
+ *
+ */
+export class OINOModelSet {
+    /** Reference to datamodel */
+    datamodel;
+    /** Reference to data set */
+    dataset;
+    /** SQL parameters */
+    queryParams;
+    /** Collection of errors */
+    errors;
+    /**
+     * Constructor for `OINOModelSet`.
+     *
+     * @param datamodel data model
+     * @param dataset data set
+     * @param queryParams SQL parameters
+     */
+    constructor(datamodel, dataset, queryParams) {
+        this.datamodel = datamodel;
+        this.dataset = dataset;
+        this.queryParams = queryParams;
+        this.errors = this.dataset.messages;
+    }
+    _encodeAndHashFieldValue(field, value, contentType, primaryKeyValues, rowIdSeed) {
+        let result;
+        if (field.fieldParams.isPrimaryKey || field.fieldParams.isForeignKey) {
+            if (value && (field instanceof OINONumberDataField) && (this.datamodel.api.hashid) && ((this.queryParams?.aggregate === undefined) || (this.queryParams.aggregate.isAggregated(field.name) == false))) {
+                value = this.datamodel.api.hashid.encode(value, rowIdSeed);
+            }
+            if (field.fieldParams.isPrimaryKey) {
+                primaryKeyValues.push(value || "");
+            }
+        }
+        result = OINOStr.encode(value, contentType);
+        return result;
+    }
+    _writeRowJson(row) {
+        // console.log("OINOModelSet._writeRowJson: row=" + row)
+        const model = this.datamodel;
+        const fields = model.fields;
+        let row_id_seed = model.getRowPrimarykeyValues(row).join(' ');
+        let primary_key_values = [];
+        let json_row = "";
+        for (let i = 0; i < fields.length; i++) {
+            const f = fields[i];
+            if ((this.queryParams?.select?.isSelected(f.name) === false) && (f.fieldParams.isPrimaryKey == false)) {
+                continue;
+            }
+            let value = f.serializeCell(row[i]);
+            if (value === undefined) {
+                // skip undefined values
+            }
+            else if (value === null) {
+                json_row += "," + OINOStr.encode(f.name, OINOContentType.json) + ":null";
+            }
+            else {
+                let is_hashed = (f.fieldParams.isPrimaryKey || f.fieldParams.isForeignKey) && (f instanceof OINONumberDataField) && (this.datamodel.api.hashid != null);
+                let is_value = (f instanceof OINOBooleanDataField) || ((f instanceof OINONumberDataField) && !is_hashed);
+                value = this._encodeAndHashFieldValue(f, value, OINOContentType.json, primary_key_values, f.name + " " + row_id_seed);
+                if (is_value) {
+                    value = value.substring(1, value.length - 1);
+                }
+                json_row += "," + OINOStr.encode(f.name, OINOContentType.json) + ":" + value;
+            }
+        }
+        json_row = OINOStr.encode(OINOConfig.OINO_ID_FIELD, OINOContentType.json) + ":" + OINOStr.encode(OINOConfig.printOINOId(primary_key_values), OINOContentType.json) + json_row;
+        return "{" + json_row + "}";
+    }
+    async _writeStringJson() {
+        let result = "";
+        while (!this.dataset.isEof()) {
+            if (result != "") {
+                result += ",\r\n";
+            }
+            const row = this.dataset.getRow();
+            result += this._writeRowJson(row);
+            await this.dataset.next();
+        }
+        result = "[\r\n" + result + "\r\n]";
+        return result;
+    }
+    _writeHeaderCsv() {
+        const model = this.datamodel;
+        const fields = model.fields;
+        let csv_header = "\"" + OINOConfig.OINO_ID_FIELD + "\"";
+        for (let i = 0; i < fields.length; i++) {
+            if ((this.queryParams?.select?.isSelected(fields[i].name) === false) && (fields[i].fieldParams.isPrimaryKey == false)) {
+                continue;
+            }
+            csv_header += ",\"" + fields[i].name + "\"";
+        }
+        return csv_header;
+    }
+    _writeRowCsv(row) {
+        const model = this.datamodel;
+        const fields = model.fields;
+        let row_id_seed = model.getRowPrimarykeyValues(row).join(' ');
+        let primary_key_values = [];
+        let csv_row = "";
+        for (let i = 0; i < fields.length; i++) {
+            const f = fields[i];
+            if ((this.queryParams?.select?.isSelected(f.name) === false) && (f.fieldParams.isPrimaryKey == false)) {
+                continue;
+            }
+            let value = f.serializeCell(row[i]);
+            if (value == null) {
+                csv_row += "," + OINOStr.encode(value, OINOContentType.csv); // either null or undefined
+            }
+            else {
+                value = this._encodeAndHashFieldValue(f, value, OINOContentType.csv, primary_key_values, f.name + " " + row_id_seed);
+                csv_row += "," + value;
+            }
+        }
+        csv_row = OINOStr.encode(OINOConfig.printOINOId(primary_key_values), OINOContentType.csv) + csv_row;
+        return csv_row;
+    }
+    async _writeStringCsv() {
+        let result = this._writeHeaderCsv();
+        while (!this.dataset.isEof()) {
+            if (result != "") {
+                result += "\r\n";
+            }
+            const row = this.dataset.getRow();
+            result += this._writeRowCsv(row);
+            await this.dataset.next();
+        }
+        return result;
+    }
+    _writeRowFormdataParameterBlock(blockName, blockValue, multipartBoundary) {
+        if (blockValue === null) {
+            return multipartBoundary + "\r\n" + "Content-Disposition: form-data; name=\"" + blockName + "\"\r\n\r\n";
+        }
+        else {
+            return multipartBoundary + "\r\n" + "Content-Disposition: form-data; name=\"" + blockName + "\"\r\n\r\n" + blockValue + "\r\n";
+        }
+    }
+    _writeRowFormdataFileBlock(blockName, blockValue, multipartBoundary) {
+        return multipartBoundary + "\r\n" + "Content-Disposition: form-data; name=\"" + blockName + "\"; filename=" + blockName + "\"\r\nContent-Type: application/octet-stream\r\nContent-Transfer-Encoding: BASE64\r\n\r\n" + blockValue + "\r\n";
+    }
+    _writeRowFormdata(row) {
+        const multipart_boundary = "---------OINOMultipartBoundary35424568"; // this method is just used for test data generation and we want it to be static
+        const model = this.datamodel;
+        const fields = model.fields;
+        let row_id_seed = model.getRowPrimarykeyValues(row).join(' ');
+        let primary_key_values = [];
+        let result = "";
+        for (let i = 0; i < fields.length; i++) {
+            const f = fields[i];
+            if ((this.queryParams?.select?.isSelected(f.name) === false) && (f.fieldParams.isPrimaryKey == false)) {
+                continue;
+            }
+            let value = f.serializeCell(row[i]);
+            let formdata_block = "";
+            let is_file = (f instanceof OINOBlobDataField);
+            if (value === undefined) {
+                OINOLog.info("@oino-ts/db", "OINOModelSet", "_writeRowFormdata", "Undefined value skipped", { field_name: f.name });
+            }
+            else if (value === null) {
+                formdata_block = this._writeRowFormdataParameterBlock(fields[i].name, null, multipart_boundary);
+            }
+            else {
+                value = this._encodeAndHashFieldValue(f, value, OINOContentType.formdata, primary_key_values, f.name + " " + row_id_seed);
+                if (is_file) {
+                    formdata_block = this._writeRowFormdataFileBlock(f.name, value, multipart_boundary);
+                }
+                else {
+                    formdata_block = this._writeRowFormdataParameterBlock(fields[i].name, value, multipart_boundary);
+                }
+            }
+            result += formdata_block;
+        }
+        result = this._writeRowFormdataParameterBlock(OINOConfig.OINO_ID_FIELD, OINOConfig.printOINOId(primary_key_values), multipart_boundary) + result;
+        return result;
+    }
+    _writeStringFormdata() {
+        const row = this.dataset.getRow();
+        let result = this._writeRowFormdata(row);
+        return result;
+    }
+    _writeRowUrlencode(row) {
+        const model = this.datamodel;
+        const fields = model.fields;
+        let row_id_seed = model.getRowPrimarykeyValues(row).join(' ');
+        let primary_key_values = [];
+        let urlencode_row = "";
+        for (let i = 0; i < fields.length; i++) {
+            const f = fields[i];
+            if ((this.queryParams?.select?.isSelected(f.name) === false) && (f.fieldParams.isPrimaryKey == false)) {
+                continue;
+            }
+            let value = f.serializeCell(row[i]);
+            if ((value === undefined)) { // || (value === null)) {
+                // console.log("OINOModelSet._writeRowUrlencode undefined field value:" + fields[i].name)
+            }
+            else {
+                value = this._encodeAndHashFieldValue(f, value, OINOContentType.urlencode, primary_key_values, f.name + " " + row_id_seed);
+                if (urlencode_row != "") {
+                    urlencode_row += "&";
+                }
+                urlencode_row += OINOStr.encode(f.name, OINOContentType.urlencode) + "=" + value;
+            }
+        }
+        urlencode_row = OINOStr.encode(OINOConfig.OINO_ID_FIELD, OINOContentType.urlencode) + "=" + OINOStr.encode(OINOConfig.printOINOId(primary_key_values), OINOContentType.urlencode) + "&" + urlencode_row;
+        return urlencode_row;
+    }
+    async _writeStringUrlencode() {
+        let result = "";
+        let line_count = 0;
+        while (!this.dataset.isEof()) {
+            const row = this.dataset.getRow();
+            result += this._writeRowUrlencode(row) + "\r\n";
+            await this.dataset.next();
+            line_count += 1;
+        }
+        if (line_count > 1) {
+            OINOLog.warning("@oino-ts/db", "OINOModelSet", "_writeStringUrlencode", "Content type " + OINOContentType.urlencode + " does not officially support multiline content!", {});
+        }
+        return result;
+    }
+    _exportRow(row) {
+        // console.log("OINOModelSet._exportRow: row=" + row)
+        const model = this.datamodel;
+        const fields = model.fields;
+        let row_id_seed = model.getRowPrimarykeyValues(row).join(' ');
+        let primary_key_values = [];
+        let result = {};
+        for (let i = 0; i < fields.length; i++) {
+            const f = fields[i];
+            if (f.fieldParams.isPrimaryKey) {
+                primary_key_values.push(f.serializeCell(row[i]) || "");
+            }
+            if ((this.queryParams?.select?.isSelected(f.name) === false) && (f.fieldParams.isPrimaryKey == false)) {
+                continue;
+            }
+            let value = f.datasource.parseValueAsCell(row[i], f.nativeType); // retain original value without serialization
+            if (value === undefined) {
+                // skip undefined values
+            }
+            else if (value === null) { // differentiate null and undefined
+                result[f.name] = null;
+            }
+            else {
+                result[f.name] = value;
+            }
+        }
+        result[OINOConfig.OINO_ID_FIELD] = OINOConfig.printOINOId(primary_key_values);
+        return result;
+    }
+    /**
+     * Serialize model set in the given format.
+     *
+     * @param [contentType=OINOContentType.json] serialization content type
+     *
+     */
+    async writeString(contentType = OINOContentType.json) {
+        let result = "";
+        if (contentType == OINOContentType.csv) {
+            result += await this._writeStringCsv();
+        }
+        else if (contentType == OINOContentType.json) {
+            result += await this._writeStringJson();
+        }
+        else if (contentType == OINOContentType.formdata) {
+            result += await this._writeStringFormdata();
+        }
+        else if (contentType == OINOContentType.urlencode) {
+            result += await this._writeStringUrlencode();
+        }
+        else {
+            OINOLog.error("@oino-ts/db", "OINOModelSet", "writeString", "Content type is only for input!", { contentType: contentType });
+        }
+        return result;
+    }
+    /**
+     * Get value of given field in the current row. Undefined if no rows,
+     * field not found or value does not exist.
+     *
+     * @param fieldName name of the field
+     * @param serialize serialize the value
+     *
+     */
+    getValueByFieldName(fieldName, serialize = false) {
+        let result = undefined;
+        if (!this.dataset.isEof()) {
+            const current_row = this.dataset.getRow();
+            const field_index = this.datamodel.findFieldIndexByName(fieldName);
+            if (field_index >= 0) {
+                result = current_row[field_index];
+                if (serialize) {
+                    result = this.datamodel.fields[field_index].serializeCell(result);
+                }
+            }
+        }
+        return result;
+    }
+    /**
+     * Export all rows as a record with OINOId as key and object with row cells as values.
+     *
+     * @param idFieldName optional field name to use as key instead of OINOId
+     */
+    async exportAsRecord(idFieldName) {
+        const result = {};
+        const row_id_field = idFieldName || OINOConfig.OINO_ID_FIELD;
+        while (!this.dataset.isEof()) {
+            const row_data = this.dataset.getRow();
+            const row_export = this._exportRow(row_data);
+            const row_id = row_export[row_id_field];
+            result[row_id] = row_export;
+            await this.dataset.next();
+        }
+        return result;
+    }
+}