@oino-ts/db 0.0.11

package/dist/cjs/OINODbFactory.js

@@ -0,0 +1,563 @@
+"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.OINODbFactory = void 0;
+const index_js_1 = require("./index.js");
+/**
+ * Static factory class for easily creating things based on data
+ *
+ */
+class OINODbFactory {
+    static _dbRegistry = {};
+    /**
+     * Register a supported database class. Used to enable those that are installed in the factory
+     * instead of forcing everyone to install all database libraries.
+     *
+     * @param dbName name of the database implementation class
+     * @param dbTypeClass constructor for creating a database of that type
+     */
+    static registerDb(dbName, dbTypeClass) {
+        // OINOLog.debug("OINODbFactory.registerDb", {dbType:dbName})
+        this._dbRegistry[dbName] = dbTypeClass;
+    }
+    /**
+     * Create database from parameters from the registered classes.
+     *
+     * @param params database connection parameters
+     */
+    static async createDb(params) {
+        let result;
+        let db_type = this._dbRegistry[params.type];
+        if (db_type) {
+            result = new db_type(params);
+        }
+        else {
+            throw new Error("Unsupported database type: " + params.type);
+        }
+        await result.connect();
+        return result;
+    }
+    /**
+     * Create API from parameters and calls initDatamodel on the datamodel.
+     *
+     * @param db databased used in API
+     * @param params parameters of the API
+     */
+    static async createApi(db, params) {
+        let result = new index_js_1.OINODbApi(db, params);
+        await db.initializeApiDatamodel(result);
+        return result;
+    }
+    /**
+     * Creates a key-value-collection from Javascript URL parameters.
+     *
+     * @param request HTTP Request
+     */
+    static createParamsFromRequest(request) {
+        let result = { sqlParams: {} };
+        const url = new URL(request.url);
+        const content_type = request.headers.get("content-type");
+        if (content_type == index_js_1.OINOContentType.csv) {
+            result.requestType = index_js_1.OINOContentType.csv;
+        }
+        else if (content_type == index_js_1.OINOContentType.urlencode) {
+            result.requestType = index_js_1.OINOContentType.urlencode;
+        }
+        else if (content_type?.startsWith(index_js_1.OINOContentType.formdata)) {
+            result.requestType = index_js_1.OINOContentType.formdata;
+            result.multipartBoundary = content_type.split('boundary=')[1] || "";
+        }
+        else {
+            result.requestType = index_js_1.OINOContentType.json;
+        }
+        const accept = request.headers.get("accept");
+        // OINOLog.debug("createParamsFromRequest: accept headers", {accept:accept})
+        const accept_types = accept?.split(', ') || [];
+        for (let i = 0; i < accept_types.length; i++) {
+            if (Object.values(index_js_1.OINOContentType).includes(accept_types[i])) {
+                result.responseType = accept_types[i];
+                // OINOLog.debug("createParamsFromRequest: response type found", {respnse_type:result.responseType})
+                break;
+            }
+        }
+        if (result.responseType === undefined) {
+            result.responseType = index_js_1.OINOContentType.json;
+        }
+        const filter = url.searchParams.get(index_js_1.OINODbConfig.OINODB_SQL_FILTER_PARAM);
+        if (filter) {
+            result.sqlParams.filter = index_js_1.OINODbSqlFilter.parse(filter);
+        }
+        const order = url.searchParams.get(index_js_1.OINODbConfig.OINODB_SQL_ORDER_PARAM);
+        if (order) {
+            result.sqlParams.order = new index_js_1.OINODbSqlOrder(order);
+        }
+        const limit = url.searchParams.get(index_js_1.OINODbConfig.OINODB_SQL_LIMIT_PARAM);
+        if (limit) {
+            result.sqlParams.limit = new index_js_1.OINODbSqlLimit(limit);
+        }
+        // OINOLog.debug("createParamsFromRequest", {params:result})
+        return result;
+    }
+    /**
+     * Creates a HTTP Response from API results.
+     *
+     * @param apiResult API results
+     * @param requestParams API request parameters
+     * @param responseHeaders Headers to include in the response
+     *
+     */
+    static createResponseFromApiResult(apiResult, requestParams, responseHeaders = {}) {
+        let response = null;
+        if (apiResult.success && apiResult.data) {
+            response = new Response(apiResult.data.writeString(requestParams.responseType), { status: apiResult.statusCode, statusText: apiResult.statusMessage, headers: responseHeaders });
+        }
+        else {
+            response = new Response(JSON.stringify(apiResult), { status: apiResult.statusCode, statusText: apiResult.statusMessage, headers: responseHeaders });
+        }
+        for (let i = 0; i < apiResult.messages.length; i++) {
+            response.headers.set('X-OINO-MESSAGE-' + i, apiResult.messages[i]);
+        }
+        return response;
+    }
+    /**
+     * Creates HTML Response from API modelset.
+     *
+     * @param modelset OINO API dataset
+     * @param template HTML template
+     *
+     */
+    static createHtmlFromData(modelset, template) {
+        let result = "";
+        const dataset = modelset.dataset;
+        const datamodel = modelset.datamodel;
+        while (!dataset.isEof()) {
+            const row = dataset.getRow();
+            let row_id_seed = datamodel.getRowPrimarykeyValues(row).join(' ');
+            let primary_key_values = [];
+            let html_row = template.replaceAll('###' + index_js_1.OINODbConfig.OINODB_ID_FIELD + '###', '###createHtmlFromData_temporary_oinoid###');
+            for (let i = 0; i < datamodel.fields.length; i++) {
+                const f = datamodel.fields[i];
+                let value = f.serializeCell(row[i]);
+                if (f.fieldParams.isPrimaryKey) {
+                    if (value && (f instanceof index_js_1.OINONumberDataField) && (datamodel.api.hashid)) {
+                        value = datamodel.api.hashid.encode(value, f.name + " " + row_id_seed);
+                    }
+                    primary_key_values.push(value || "");
+                }
+                html_row = html_row.replaceAll('###' + f.name + '###', index_js_1.OINOStr.encode(value, index_js_1.OINOContentType.html));
+            }
+            html_row = html_row.replaceAll('###createHtmlFromData_temporary_oinoid###', index_js_1.OINOStr.encode(index_js_1.OINODbConfig.printOINOId(primary_key_values), index_js_1.OINOContentType.html));
+            result += html_row + "\r\n";
+            dataset.next();
+        }
+        return result;
+    }
+    /**
+     * Creates HTML Response from a row id.
+     *
+     * @param oinoId OINO id
+     * @param template HTML template
+     *
+     */
+    static createHtmlFromOinoId(oinoId, template) {
+        let result = template.replaceAll('###' + index_js_1.OINODbConfig.OINODB_ID_FIELD + '###', index_js_1.OINOStr.encode(oinoId, index_js_1.OINOContentType.html));
+        return result;
+    }
+    /**
+     * Creates HTML Response from object properties.
+     *
+     * @param object object
+     * @param template HTML template
+     *
+     */
+    static createHtmlFromObject(object, template) {
+        let result = template;
+        for (let key in object) {
+            const value = object[key];
+            if (value) {
+                result = result.replaceAll('###' + key + '###', index_js_1.OINOStr.encode(value.toString(), index_js_1.OINOContentType.html));
+            }
+        }
+        result = result.replace(/###[^#]*###/g, "");
+        return result;
+    }
+    /**
+     * Creates HTML Response from API result.
+     *
+     * @param apiResult object
+     * @param template HTML template
+     * @param includeErrorMessages include debug messages in result
+     * @param includeWarningMessages include debug messages in result
+     * @param includeInfoMessages include debug messages in result
+     * @param includeDebugMessages include debug messages in result
+     *
+     */
+    static createHtmlFromApiResult(apiResult, template, includeErrorMessages = false, includeWarningMessages = false, includeInfoMessages = false, includeDebugMessages = false) {
+        let result = template;
+        result = result.replaceAll('###statusCode###', index_js_1.OINOStr.encode(apiResult.statusCode.toString(), index_js_1.OINOContentType.html));
+        result = result.replaceAll('###statusMessage###', index_js_1.OINOStr.encode(apiResult.statusMessage.toString(), index_js_1.OINOContentType.html));
+        let messages = "";
+        for (let i = 0; i < apiResult.messages.length; i++) {
+            if (includeErrorMessages && apiResult.messages[i].startsWith(index_js_1.OINO_ERROR_PREFIX)) {
+                messages += "<li>" + index_js_1.OINOStr.encode(apiResult.messages[i], index_js_1.OINOContentType.html) + "</li>";
+            }
+            if (includeWarningMessages && apiResult.messages[i].startsWith(index_js_1.OINO_WARNING_PREFIX)) {
+                messages += "<li>" + index_js_1.OINOStr.encode(apiResult.messages[i], index_js_1.OINOContentType.html) + "</li>";
+            }
+            if (includeInfoMessages && apiResult.messages[i].startsWith(index_js_1.OINO_INFO_PREFIX)) {
+                messages += "<li>" + index_js_1.OINOStr.encode(apiResult.messages[i], index_js_1.OINOContentType.html) + "</li>";
+            }
+            if (includeDebugMessages && apiResult.messages[i].startsWith(index_js_1.OINO_DEBUG_PREFIX)) {
+                messages += "<li>" + index_js_1.OINOStr.encode(apiResult.messages[i], index_js_1.OINOContentType.html) + "</li>";
+            }
+        }
+        if (messages) {
+            result = result.replaceAll('###messages###', "<ul>" + messages + "</ul>");
+        }
+        result = result.replace(/###[^#]*###/g, "");
+        return result;
+    }
+    static _findCsvLineEnd(csvData, start) {
+        const n = csvData.length;
+        if (start >= n) {
+            return start;
+        }
+        let end = start;
+        let quote_open = false;
+        while (end < n) {
+            if (csvData[end] == "\"") {
+                if (!quote_open) {
+                    quote_open = true;
+                }
+                else if ((end < n - 1) && (csvData[end + 1] == "\"")) {
+                    end++;
+                }
+                else {
+                    quote_open = false;
+                }
+            }
+            else if ((!quote_open) && (csvData[end] == "\r")) {
+                return end;
+            }
+            end++;
+        }
+        return n;
+    }
+    static _parseCsvLine(csvLine) {
+        let result = [];
+        const n = csvLine.length;
+        let start = 0;
+        let end = 0;
+        let quote_open = false;
+        let has_quotes = false;
+        let has_escaped_quotes = false;
+        let found_field = false;
+        while (end < n) {
+            if (csvLine[end] == "\"") {
+                if (!quote_open) {
+                    quote_open = true;
+                }
+                else if ((end < n - 1) && (csvLine[end + 1] == "\"")) {
+                    end++;
+                    has_escaped_quotes = true;
+                }
+                else {
+                    has_quotes = true;
+                    quote_open = false;
+                }
+            }
+            if ((!quote_open) && ((end == n - 1) || (csvLine[end] == ","))) {
+                found_field = true;
+                if (end == n - 1) {
+                    end++;
+                }
+            }
+            if (found_field) {
+                // console.log("OINODB_csvParseLine: next field=" + csvLine.substring(start,end) + ", start="+start+", end="+end)
+                let field_str;
+                if (has_quotes) {
+                    field_str = csvLine.substring(start + 1, end - 1);
+                }
+                else if (start == end) {
+                    field_str = undefined;
+                }
+                else {
+                    field_str = csvLine.substring(start, end);
+                    if (field_str == "null") {
+                        field_str = null;
+                    }
+                }
+                result.push(field_str);
+                has_quotes = false;
+                has_escaped_quotes = true;
+                found_field = false;
+                start = end + 1;
+            }
+            end++;
+        }
+        return result;
+    }
+    static createRowFromCsv(datamodel, data) {
+        let result = [];
+        const n = data.length;
+        let start = 0;
+        let end = this._findCsvLineEnd(data, start);
+        const header_str = data.substring(start, end);
+        const headers = this._parseCsvLine(header_str);
+        let field_to_header_mapping = new Array(datamodel.fields.length);
+        let headers_found = false;
+        for (let i = 0; i < field_to_header_mapping.length; i++) {
+            field_to_header_mapping[i] = headers.indexOf(datamodel.fields[i].name);
+            headers_found = headers_found || (field_to_header_mapping[i] >= 0);
+        }
+        // OINOLog.debug("createRowFromCsv", {headers:headers, field_to_header_mapping:field_to_header_mapping})
+        if (!headers_found) {
+            return result;
+        }
+        start = end + 1;
+        end = start;
+        while (end < n) {
+            while ((start < n) && ((data[start] == "\r") || (data[start] == "\n"))) {
+                start++;
+            }
+            if (start >= n) {
+                return result;
+            }
+            end = this._findCsvLineEnd(data, start);
+            const row_data = this._parseCsvLine(data.substring(start, end));
+            const row = new Array(field_to_header_mapping.length);
+            for (let i = 0; i < datamodel.fields.length; i++) {
+                const field = datamodel.fields[i];
+                let j = field_to_header_mapping[i];
+                let value = row_data[j];
+                if ((value === undefined) || (value === null)) { // null/undefined-decoding built into the parser
+                    row[i] = value;
+                }
+                else if ((j >= 0) && (j < row_data.length)) {
+                    value = index_js_1.OINOStr.decode(value, index_js_1.OINOContentType.csv);
+                    if (value && field.fieldParams.isPrimaryKey && (field instanceof index_js_1.OINONumberDataField) && (datamodel.api.hashid)) {
+                        value = datamodel.api.hashid.decode(value);
+                    }
+                    row[i] = field.deserializeCell(value);
+                }
+                else {
+                    row[i] = undefined;
+                }
+            }
+            // console.log("createRowFromCsv: next row=" + row)
+            result.push(row);
+            start = end;
+            end = start;
+        }
+        return result;
+    }
+    static _createRowFromJsonObj(obj, datamodel) {
+        // console.log("createRowFromJsonObj: obj=" + JSON.stringify(obj))
+        const fields = datamodel.fields;
+        let result = new Array(fields.length);
+        //  console.log("createRowFromJsonObj: " + result)
+        for (let i = 0; i < fields.length; i++) {
+            const field = fields[i];
+            let value = index_js_1.OINOStr.decode(obj[field.name], index_js_1.OINOContentType.json);
+            // console.log("createRowFromJsonObj: key=" + field.name + ", val=" + val)
+            if ((value === undefined) || (value === null)) {
+                result[i] = value;
+            }
+            else {
+                if (Array.isArray(value) || typeof value === "object") { // only single level deep object, rest is handled as JSON-strings
+                    result[i] = JSON.stringify(value).replaceAll("\"", "\\\"");
+                }
+                else {
+                    if (value && field.fieldParams.isPrimaryKey && (field instanceof index_js_1.OINONumberDataField) && (datamodel.api.hashid)) {
+                        value = datamodel.api.hashid.decode(value);
+                    }
+                    result[i] = field.deserializeCell(value);
+                }
+            }
+            // console.log("createRowFromJsonObj: result["+i+"]=" + result[i])
+        }
+        // console.log("createRowFromJsonObj: " + result)
+        return result;
+    }
+    static _createRowFromJson(datamodel, data) {
+        try {
+            let result = [];
+            // console.log("OINORowFactoryJson: data=" + data)
+            const obj = JSON.parse(data);
+            if (Array.isArray(obj)) {
+                obj.forEach(row => {
+                    result.push(this._createRowFromJsonObj(row, datamodel));
+                });
+            }
+            else {
+                result.push(this._createRowFromJsonObj(obj, datamodel));
+            }
+            return result;
+        }
+        catch (e) {
+            return [];
+        }
+    }
+    static _findMultipartBoundary(formData, multipartBoundary, start) {
+        let n = formData.indexOf(multipartBoundary, start);
+        if (n >= 0) {
+            n += multipartBoundary.length + 2;
+        }
+        else {
+            n = formData.length;
+        }
+        return n;
+    }
+    static _parseMultipartLine(csvData, start) {
+        let line_end = csvData.indexOf('\r\n', start);
+        if (line_end >= start) {
+            return csvData.substring(start, line_end);
+        }
+        else {
+            return '';
+        }
+    }
+    static _multipartHeaderRegex = /Content-Disposition\: (form-data|file); name=\"([^\"]+)\"(; filename=.*)?/i;
+    static createRowFromFormdata(datamodel, data, multipartBoundary) {
+        let result = [];
+        const n = data.length;
+        let start = this._findMultipartBoundary(data, multipartBoundary, 0);
+        let end = this._findMultipartBoundary(data, multipartBoundary, start);
+        // OINOLog.debug("createRowFromFormdata: enter", {start:start, end:end, multipartBoundary:multipartBoundary})
+        const row = new Array(datamodel.fields.length);
+        while (end < n) {
+            // OINOLog.debug("createRowFromFormdata: next block", {start:start, end:end, block:data.substring(start, end)})
+            let block_ok = true;
+            let l = this._parseMultipartLine(data, start);
+            // OINOLog.debug("createRowFromFormdata: next line", {start:start, end:end, line:l})
+            start += l.length + 2;
+            const header_matches = OINODbFactory._multipartHeaderRegex.exec(l);
+            if (!header_matches) {
+                index_js_1.OINOLog.warning("OINODbFactory.createRowFromFormdata: unsupported block skipped!", { header_line: l });
+                block_ok = false;
+            }
+            else {
+                const field_name = header_matches[2];
+                const is_file = header_matches[3] != null;
+                let is_base64 = false;
+                const field_index = datamodel.findFieldIndexByName(field_name);
+                // OINOLog.debug("createRowFromFormdata: header", {field_name:field_name, field_index:field_index, is_file:is_file})
+                if (field_index < 0) {
+                    index_js_1.OINOLog.warning("OINODbFactory.createRowFromFormdata: form field not found and skipped!", { field_name: field_name });
+                    block_ok = false;
+                }
+                else {
+                    const field = datamodel.fields[field_index];
+                    l = this._parseMultipartLine(data, start);
+                    // OINOLog.debug("createRowFromFormdata: next line", {start:start, end:end, line:l})
+                    while (block_ok && (l != '')) {
+                        if (l.startsWith('Content-Type:') && (l.indexOf('multipart/mixed') >= 0)) {
+                            index_js_1.OINOLog.warning("OINODbFactory.createRowFromFormdata: mixed multipart files not supported and skipped!", { header_line: l });
+                            block_ok = false;
+                        }
+                        else if (l.startsWith('Content-Transfer-Encoding:') && (l.indexOf('BASE64') >= 0)) {
+                            is_base64 = true;
+                        }
+                        start += l.length + 2;
+                        l = this._parseMultipartLine(data, start);
+                        // OINOLog.debug("createRowFromFormdata: next line", {start:start, end:end, line:l})
+                    }
+                    start += 2;
+                    if (!block_ok) {
+                        index_js_1.OINOLog.warning("OINODbFactory.createRowFromFormdata: invalid block skipped", { field_name: field_name });
+                    }
+                    else if (start + multipartBoundary.length + 2 >= end) {
+                        // OINOLog.debug("OINODbFactory.createRowFromFormdata: null value", {field_name:field_name})
+                        row[field_index] = null;
+                    }
+                    else if (is_file) {
+                        const value = this._parseMultipartLine(data, start).trim();
+                        if (is_base64) {
+                            row[field_index] = field.deserializeCell(index_js_1.OINOStr.decode(value, index_js_1.OINOContentType.formdata));
+                        }
+                        else {
+                            row[field_index] = Buffer.from(value, "binary");
+                        }
+                    }
+                    else {
+                        let value = index_js_1.OINOStr.decode(this._parseMultipartLine(data, start).trim(), index_js_1.OINOContentType.formdata);
+                        // OINOLog.debug("OINODbFactory.createRowFromFormdata: parse form field", {field_name:field_name, value:value})
+                        if (value && field.fieldParams.isPrimaryKey && (field instanceof index_js_1.OINONumberDataField) && (datamodel.api.hashid)) {
+                            value = datamodel.api.hashid.decode(value);
+                        }
+                        row[field_index] = field.deserializeCell(value);
+                    }
+                }
+            }
+            start = end;
+            end = this._findMultipartBoundary(data, multipartBoundary, start);
+        }
+        index_js_1.OINOLog.debug("createRowFromFormdata: next row", { row: row });
+        result.push(row);
+        return result;
+    }
+    static createRowFromUrlencoded(datamodel, data) {
+        // OINOLog.debug("createRowFromUrlencoded: enter", {data:data})
+        let result = [];
+        const row = new Array(datamodel.fields.length);
+        const data_parts = data.trim().split('&');
+        for (let i = 0; i < data_parts.length; i++) {
+            const param_parts = data_parts[i].split('=');
+            index_js_1.OINOLog.debug("createRowFromUrlencoded: next param", { param_parts: param_parts });
+            if (param_parts.length == 2) {
+                const key = index_js_1.OINOStr.decodeUrlencode(param_parts[0]) || "";
+                const field_index = datamodel.findFieldIndexByName(key);
+                if (field_index < 0) {
+                    index_js_1.OINOLog.info("createRowFromUrlencoded: param field not found", { field: key });
+                }
+                else {
+                    const field = datamodel.fields[field_index];
+                    let value = index_js_1.OINOStr.decode(param_parts[1], index_js_1.OINOContentType.urlencode);
+                    if (value && field.fieldParams.isPrimaryKey && (field instanceof index_js_1.OINONumberDataField) && (datamodel.api.hashid)) {
+                        value = datamodel.api.hashid.decode(value);
+                    }
+                    row[field_index] = field.deserializeCell(value);
+                }
+            }
+            // const value = requestParams[]
+        }
+        console.log("createRowFromUrlencoded: next row=" + row);
+        result.push(row);
+        return result;
+    }
+    /**
+      * Create data rows from request body based on the datamodel.
+      *
+      * @param datamodel datamodel of the api
+      * @param data data as a string
+      * @param requestParams parameters
+      *
+      */
+    static createRows(datamodel, data, requestParams) {
+        if ((requestParams.requestType == index_js_1.OINOContentType.json) || (requestParams.requestType == undefined)) {
+            return this._createRowFromJson(datamodel, data);
+        }
+        else if (requestParams.requestType == index_js_1.OINOContentType.csv) {
+            return this.createRowFromCsv(datamodel, data);
+        }
+        else if (requestParams.requestType == index_js_1.OINOContentType.formdata) {
+            return this.createRowFromFormdata(datamodel, data, requestParams.multipartBoundary || "");
+        }
+        else if (requestParams.requestType == index_js_1.OINOContentType.urlencode) {
+            return this.createRowFromUrlencoded(datamodel, data);
+        }
+        else if (requestParams.requestType == index_js_1.OINOContentType.html) {
+            index_js_1.OINOLog.error("HTML can't be used as an input content type!", { contentType: index_js_1.OINOContentType.html });
+            return [];
+        }
+        else {
+            index_js_1.OINOLog.error("Unrecognized input content type!", { contentType: requestParams.requestType });
+            return [];
+        }
+    }
+}
+exports.OINODbFactory = OINODbFactory;