@oino-ts/db 0.0.11

package/src/OINODb.ts

@@ -0,0 +1,98 @@
+/*
+ * 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 { OINODbParams, OINODbApi, OINODataCell, OINODbDataSet } from "./index.js"
+
+/**
+ * Base class for database abstraction, implementing methods for connecting, making queries and parsing/formatting data 
+ * between SQL and serialization formats.
+ *
+ */
+export abstract class OINODb {
+    
+    protected _params:OINODbParams
+
+    /** Name of the database */
+    readonly name:string
+
+    /**
+     * Constructor for `OINODb`.
+     * @param params database parameters
+     */
+    constructor(params:OINODbParams) {
+        this._params = params
+        this.name = params.database
+    }
+
+    /**
+     * Connect to database.
+     *
+     */
+    abstract connect(): Promise<boolean>
+    
+    /**
+     * Print a table name using database specific SQL escaping.
+     * 
+     * @param sqlTable name of the table
+     *
+     */
+    abstract printSqlTablename(sqlTable:string): string
+
+    /**
+     * Print a column name with correct SQL escaping.
+     * 
+     * @param sqlColumn name of the column
+     *
+     */
+    abstract printSqlColumnname(sqlColumn:string): string
+
+    /**
+     * Print a single data value from serialization using the context of the native data
+     * type with the correct SQL escaping.
+     * 
+     * @param cellValue data from sql results
+     * @param sqlType native type name for table column
+     *
+     */
+    abstract printCellAsSqlValue(cellValue:OINODataCell, sqlType: string): string
+
+    /**
+     * Parse a single SQL result value for serialization using the context of the native data
+     * type.
+     * 
+     * @param sqlValue data from serialization
+     * @param sqlType native type name for table column
+     * 
+     */
+    abstract parseSqlValueAsCell(sqlValue:OINODataCell, sqlType: string): OINODataCell
+    
+    /**
+     * Execute a select operation.
+     * 
+     * @param sql SQL statement.
+     *
+     */
+    abstract sqlSelect(sql:string): Promise<OINODbDataSet>
+
+    /**
+     * Execute other sql operations.
+     * 
+     * @param sql SQL statement.
+     *
+     */
+    abstract sqlExec(sql:string): Promise<OINODbDataSet>
+
+    /**
+     * Initialize a data model by getting the SQL schema and populating OINODbDataFields of 
+     * the model.
+     * 
+     * @param api api which data model to initialize.
+     *
+     */
+    abstract initializeApiDatamodel(api:OINODbApi): Promise<void>
+}
+
+

package/src/OINODbApi.test.ts

@@ -0,0 +1,243 @@
+/*
+ * 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 { expect, test } from "bun:test";
+
+import { OINODbApi, OINODbApiParams, OINOContentType, OINODataRow, OINODbDataField, OINOStringDataField, OINODb, OINODbFactory, OINODbParams, OINODbMemoryDataSet, OINODbModelSet, OINOBenchmark, OINOConsoleLog, OINORequestParams, OINODbSqlFilter, OINODbConfig, OINODbSqlOrder, OINOLogLevel, OINOLog } from "./index.js";
+
+import { OINODbBunSqlite } from "@oino-ts/db-bunsqlite"
+import { OINODbPostgresql } from "@oino-ts/db-postgresql"
+import { OINODbMariadb } from "@oino-ts/db-mariadb"
+
+Math.random()
+
+OINOLog.setLogger(new OINOConsoleLog(OINOLogLevel.error))
+OINODbFactory.registerDb("OINODbBunSqlite", OINODbBunSqlite)
+OINODbFactory.registerDb("OINODbPostgresql", OINODbPostgresql)
+OINODbFactory.registerDb("OINODbMariadb", OINODbMariadb)
+
+export async function OINOTestApi(dbParams:OINODbParams, apiDataset: OINOTestApiParams) {
+    // OINOLog.info("OINOTestApi", {dbParams:dbParams, apiDataset:apiDataset})
+    const db:OINODb = await OINODbFactory.createDb( dbParams )
+    const api:OINODbApi = await OINODbFactory.createApi(db, apiDataset.apiParams)
+    
+    const post_dataset:OINODbMemoryDataSet = new OINODbMemoryDataSet([apiDataset.postRow])
+    const post_modelset:OINODbModelSet = new OINODbModelSet(api.datamodel, post_dataset)
+    
+    const put_dataset:OINODbMemoryDataSet = new OINODbMemoryDataSet([apiDataset.putRow])
+    const put_modelset:OINODbModelSet = new OINODbModelSet(api.datamodel, put_dataset)
+    
+    // const new_row_id:string = OINODbConfig.printOINOId(post_modelset.datamodel.getRowPrimarykeyValues(apiDataset.postRow))
+    const new_row_id:string = OINODbConfig.printOINOId(post_modelset.datamodel.getRowPrimarykeyValues(apiDataset.postRow, true))
+    OINOLog.debug("OINOTestApi", {new_row_id:new_row_id})
+
+    const empty_params:OINORequestParams = { sqlParams: {}}
+    
+    const target_db:string = "[" + dbParams.type + "]"
+    let target_table:string = "[" + apiDataset.apiParams.tableName + "]"
+    let target_group:string = "[SCHEMA]"
+
+    // test("dummy", () => {
+    //     expect({foo:"h\\i"}).toMatchSnapshot()
+    // })
+
+    test(target_db + target_table + target_group + " public properties", async () => {
+        expect(api.datamodel.printFieldPublicPropertiesJson()).toMatchSnapshot()
+    })
+    
+    target_group = "[HTTP GET]"
+    test(target_db + target_table + target_group + " select *", async () => {
+        expect((await api.doRequest("GET", "", "", empty_params)).data?.writeString()).toMatchSnapshot("GET JSON")
+    })
+    
+    test(target_db + target_table + target_group + " select *", async () => {
+        expect((await api.doRequest("GET", "", "", empty_params)).data?.writeString(OINOContentType.csv)).toMatchSnapshot("GET CSV")
+    })
+
+
+    test(target_db + target_table + target_group + " select * with filter", async () => {
+        expect((await api.doRequest("GET", "", "", apiDataset.requestParams)).data?.writeString()).toMatchSnapshot("GET JSON FILTER")
+        apiDataset.requestParams.sqlParams.filter = undefined // remove filter so it does not affect rest of the tests
+    })
+    
+    target_group = "[HTTP POST]"
+    const post_body_json:string = post_modelset.writeString(OINOContentType.json)
+    OINOLog.info("HTTP POST json", {post_body_json:post_body_json})
+    test(target_db + target_table + target_group + " insert with id", async () => {
+        expect((await api.doRequest("POST", new_row_id, post_body_json, empty_params))).toMatchSnapshot("POST")
+    })
+    test(target_db + target_table + target_group + " insert", async () => {
+        expect((await api.doRequest("POST", "", post_body_json, empty_params))).toMatchSnapshot("POST")
+        expect((await api.doRequest("GET", new_row_id, "", empty_params)).data?.writeString()).toMatchSnapshot("GET JSON")
+        expect((await api.doRequest("GET", new_row_id, "", empty_params)).data?.writeString(OINOContentType.csv)).toMatchSnapshot("GET CSV")
+    })
+    test(target_db + target_table + target_group + " insert no data", async () => {
+        expect((await api.doRequest("POST", "", "", empty_params))).toMatchSnapshot("POST")
+    })
+    test(target_db + target_table + target_group + " insert duplicate", async () => {
+        expect((await api.doRequest("POST", "", post_body_json, empty_params))).toMatchSnapshot("POST")
+    })
+    
+    target_group = "[HTTP PUT]"
+    const put_body_json = put_modelset.writeString(OINOContentType.json)
+    OINOLog.info("HTTP PUT JSON", {put_body_json:put_body_json})
+    test(target_db + target_table + target_group + " update JSON", async () => {
+        apiDataset.requestParams.requestType = OINOContentType.json
+        expect((await api.doRequest("PUT", new_row_id, post_body_json, empty_params))).toMatchSnapshot("PUT JSON reset")
+        expect((await api.doRequest("PUT", new_row_id, put_body_json, empty_params))).toMatchSnapshot("PUT JSON")
+        expect((await api.doRequest("GET", new_row_id, "", empty_params)).data?.writeString()).toMatchSnapshot("GET JSON")
+    })
+
+    put_dataset.first()
+    const put_body_csv = put_modelset.writeString(OINOContentType.csv)
+    OINOLog.info("HTTP PUT csv", {put_body_csv:put_body_csv})
+    test(target_db + target_table + target_group + " update CSV", async () => {
+        apiDataset.requestParams.requestType = OINOContentType.csv
+        expect((await api.doRequest("PUT", new_row_id, post_body_json, empty_params))).toMatchSnapshot("PUT CSV reset")
+        expect((await api.doRequest("PUT", new_row_id, put_body_csv, apiDataset.requestParams))).toMatchSnapshot("PUT CSV")
+        expect((await api.doRequest("GET", new_row_id, "", empty_params)).data?.writeString(OINOContentType.csv)).toMatchSnapshot("GET CSV")
+    })
+    
+    put_dataset.first()
+    let put_body_formdata = put_modelset.writeString(OINOContentType.formdata)
+    const multipart_boundary = put_body_formdata.substring(0, put_body_formdata.indexOf('\r'))
+    put_body_formdata.replaceAll(multipart_boundary, "---------OINO999999999")
+    OINOLog.info("HTTP PUT FORMDATA", {put_body_formdata:put_body_formdata})
+    test(target_db + target_table + target_group + " update FORMDATA", async () => {
+        apiDataset.requestParams.requestType = OINOContentType.formdata
+        apiDataset.requestParams.multipartBoundary = multipart_boundary
+        expect((await api.doRequest("PUT", new_row_id, post_body_json, empty_params))).toMatchSnapshot("PUT FORMDATA reset")
+        expect((await api.doRequest("PUT", new_row_id, put_body_formdata, apiDataset.requestParams))).toMatchSnapshot("PUT FORMDATA")
+        expect((await api.doRequest("GET", new_row_id, "", empty_params)).data?.writeString(OINOContentType.formdata)).toMatchSnapshot("GET FORMDATA")
+        apiDataset.requestParams.multipartBoundary = undefined
+    })
+    
+    put_dataset.first()
+    const put_body_urlencode = put_modelset.writeString(OINOContentType.urlencode)
+    OINOLog.info("HTTP PUT URLENCODE", {put_body_urlencode:put_body_urlencode})
+    test(target_db + target_table + target_group + " update URLENCODE", async () => {
+        apiDataset.requestParams.requestType = OINOContentType.urlencode
+        expect((await api.doRequest("PUT", new_row_id, post_body_json, empty_params))).toMatchSnapshot("PUT URLENCODE reset")
+        expect((await api.doRequest("PUT", new_row_id, put_body_urlencode, apiDataset.requestParams))).toMatchSnapshot("PUT URLENCODE")
+        expect((await api.doRequest("GET", new_row_id, "", empty_params)).data?.writeString(OINOContentType.urlencode)).toMatchSnapshot("GET URLENCODE")
+    })
+    
+    test(target_db + target_table + target_group + " update no data", async () => {
+        expect((await api.doRequest("PUT", new_row_id, "", empty_params))).toMatchSnapshot("PUT")
+    })
+
+    const primary_keys:OINODbDataField[] = api.datamodel.filterFields((field:OINODbDataField) => { return field.fieldParams.isPrimaryKey })
+    if (primary_keys.length != 1) {
+        OINOLog.info("HTTP PUT table " + apiDataset.apiParams.tableName + " does not have an individual primary key so 'invalid null' and 'oversized data' tests are skipped")
+    } else {
+        const id_field:string = primary_keys[0].name 
+        const notnull_fields:OINODbDataField[] = api.datamodel.filterFields((field:OINODbDataField) => { return (field.fieldParams.isPrimaryKey == false) && (field.fieldParams.isNotNull == true) })
+        if (notnull_fields.length > 0) {
+            const invalid_null_value = "[{\"" + id_field + "\":\"" + new_row_id + "\",\"" + notnull_fields[0].name + "\":null}]"
+            test(target_db + target_table + target_group + " update with invalid null value", async () => {
+                expect((await api.doRequest("PUT", new_row_id, invalid_null_value, empty_params))).toMatchSnapshot("PUT")
+            })
+        }
+        const maxsize_fields:OINODbDataField[] = api.datamodel.filterFields((field:OINODbDataField) => { return (field instanceof OINOStringDataField) && (field.fieldParams.isPrimaryKey == false) && (field.maxLength > 0) })
+        if (maxsize_fields.length > 0) {
+            const oversized_value = "[{\"" + id_field + "\":\"" + new_row_id + "\",\"" + maxsize_fields[0].name + "\":\"" + "".padEnd(maxsize_fields[0].maxLength+1, "z") + "\"}]"
+            test(target_db + target_table + target_group + " update with oversized data", async () => {
+                expect((await api.doRequest("PUT", new_row_id, oversized_value, empty_params))).toMatchSnapshot("PUT")
+            })
+        }
+    }
+    
+    target_group = "[HTTP DELETE]"
+    test(target_db + target_table + target_group + " remove", async () => {
+        expect((await api.doRequest("DELETE", new_row_id, "", empty_params))).toMatchSnapshot("DELETE")
+        expect((await api.doRequest("GET", new_row_id, "", empty_params)).data?.writeString()).toMatchSnapshot("GET JSON")
+    })
+}
+
+type OINOTestApiParams = {
+    apiParams: OINODbApiParams
+    requestParams: OINORequestParams
+    postRow: OINODataRow
+    putRow: OINODataRow
+}
+
+// OINOLog.setLogLevel(OINOLogLevel.debug)
+OINOBenchmark.setEnabled(["doRequest"])
+OINOBenchmark.reset()
+
+const dbs:OINODbParams[] = [
+    { type: "OINODbBunSqlite", url:"file://../localDb/northwind.sqlite", database: "Northwind" }, 
+    { type: "OINODbPostgresql", url: "localhost", database: "Northwind", port:5432, user: "node", password: Bun.env.OINODB_POSTGRESQL_TOKEN },
+    { type: "OINODbMariadb", url: "127.0.0.1", database: "Northwind", port:6543, user: "node", password: Bun.env.OINODB_MARIADB_TOKEN } 
+]
+
+const apis:OINOTestApiParams[] = [
+    {
+        apiParams: { tableName: "Orders" },
+        requestParams: {
+            sqlParams: { filter: OINODbSqlFilter.parse("(ShipPostalCode)-like(0502%)"), order: new OINODbSqlOrder("ShipPostalCode desc") }
+        },
+        postRow: [30000,"CACTU",1,new Date("2024-04-05"),new Date("2024-04-06"),new Date("2024-04-07"),2,"184.75","a'b\"c%d_e\tf\rg\nh\\i","Garden House Crowther Way","Cowes","British Isles","PO31 7PJ","UK"],
+        putRow: [30000,"CACTU",1,new Date("2023-04-05"),new Date("2023-04-06"),new Date("2023-04-07"),2,"847.51","k'l\"m%n_o\tp\rq\nr\\s","59 rue de l'Abbaye","Cowes2","Western Europe","PO31 8PJ","UK"]
+    },
+    {
+        apiParams: { tableName: "Products" },
+        requestParams: {
+            sqlParams: { filter: OINODbSqlFilter.parse("(UnitsInStock)-le(5)"), order: new OINODbSqlOrder("UnitsInStock asc,UnitPrice asc") }
+        },
+        postRow: [99, "Umeshu", 1, 1, "500 ml", 12.99, 2, 0, 20, 0],
+        putRow: [99, "Umeshu", 1, 1, undefined, 24.99, 3, 0, 20, 0]
+    },
+    {
+        apiParams: { tableName: "Employees", hashidKey: "12345678901234567890123456789012" },
+        requestParams: {
+            sqlParams: { filter: OINODbSqlFilter.parse("(TitleOfCourtesy)-eq(Ms.)"), order: new OINODbSqlOrder("LastName") }
+        },
+        postRow: [99, "LastName", "FirstName", "Title", "TitleOfCourtesy", new Date("2024-04-06"), new Date("2024-04-07"), "Address", "City", "Region", 12345, "EU", "123 456 7890", "9876", Buffer.from("OINO"), "Line1\nLine2", 1, "http://accweb/emmployees/lastnamefirstname.bmp"],
+        putRow: [99, "LastName2", "FirstName2", null, "TitleOfCourtesy2", new Date("2023-04-06"), new Date("2023-04-07"), "Address2", "City2", "Region2", 54321, "EU2", "234 567 8901", "8765", Buffer.from("OINO2"), "Line3\nLine4", 1, "http://accweb/emmployees/lastnamefirstname.bmp"],
+    },
+    {
+        apiParams: { tableName: "OrderDetails" },
+        requestParams: {
+            sqlParams: { filter: OINODbSqlFilter.parse("(Quantity)-gt(100)"), order: new OINODbSqlOrder("Quantity desc") }
+        },
+        postRow: [10249,77,12.34,56,0],
+        putRow: [10249,77,23.45,67,0]
+    }
+
+]
+for (let db of dbs) {
+    for (let api of apis) {
+        await OINOTestApi(db, api)
+    }
+}
+
+const snapshot_file = Bun.file("./node_modules/@oino-ts/db/src/__snapshots__/OINODbApi.test.ts.snap")
+await Bun.write("./node_modules/@oino-ts/db/src/__snapshots__/OINODbApi.test.ts.snap.js", snapshot_file) // copy snapshots as .js so require works (note! if run with --update-snapshots, it's still the old file)
+const snapshots = require("./__snapshots__/OINODbApi.test.ts.snap.js")
+
+const crosscheck_tests:string[] = [
+    "[HTTP GET] select *: GET JSON 1",
+    "[HTTP POST] insert: GET JSON 1",
+    "[HTTP POST] insert: GET CSV 1",
+    "[HTTP PUT] update JSON: GET JSON 1",
+    "[HTTP PUT] update CSV: GET CSV 1",
+    "[HTTP PUT] update FORMDATA: GET FORMDATA 1",
+    "[HTTP PUT] update URLENCODE: GET URLENCODE 1"
+]
+
+for (let i=0; i<dbs.length-1; i++) {
+    const db1:string = dbs[i].type
+    const db2:string = dbs[i+1].type
+    for (let api of apis) {
+        const table_name = api.apiParams.tableName
+        for (let test_name of crosscheck_tests) {
+            test("cross check {" + db1 + "} and {" + db2 + "} table {" + table_name + "} snapshots on {" + test_name + "}", () => {
+                expect(snapshots["[" + db1 + "][" + table_name + "]" + test_name]).toMatch(snapshots["[" + db2 + "][" + table_name + "]" + test_name])
+            })
+        }        
+    }
+}

package/src/OINODbApi.ts

@@ -0,0 +1,270 @@
+/*
+ * 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 { OINODbApiParams, OINODb, OINODbDataSet, OINODbDataModel, OINODbDataField, OINOStringDataField, OINO_ERROR_PREFIX, OINO_WARNING_PREFIX, OINO_INFO_PREFIX, OINODataRow, OINODataCell, OINODbModelSet, OINOBenchmark, OINODbFactory, OINORequestParams, OINO_DEBUG_PREFIX, OINOLog, OINOResult } from "./index.js"
+import { OINOHashid } from "@oino-ts/hashid"
+
+/**
+ * OINO API request result object with returned data and/or http status code/message and 
+ * error / warning messages.
+ *
+ */
+export class OINODbApiResult extends OINOResult {
+    /** Returned data if any */
+    data?: OINODbModelSet;
+
+    /**
+     * Constructor of OINODbApiResult.
+     * 
+     * @param data result data
+     *
+     */
+    constructor (data?:OINODbModelSet) {
+        super()
+        this.data = data
+    }
+}
+
+/**
+ * API class with method to process HTTP REST requests.
+ *
+ */
+export class OINODbApi {
+    /** API database reference */
+    readonly db: OINODb
+
+    /** API datamodel */
+    readonly datamodel: OINODbDataModel
+
+    /** API parameters */
+    readonly params: OINODbApiParams
+
+    /** API hashid */
+    readonly hashid:OINOHashid|null
+
+    /**
+     * Constructor of API object.
+     * NOTE! OINODb.initDatamodel must be called if created manually instead of the factory.
+     *
+     * @param db database for the API
+     * @param params parameters for the API
+     * 
+     */
+    constructor (db: OINODb, params:OINODbApiParams) {
+        // OINOLog.debug("OINODbApi.constructor", {db:db, tableName:tableName, params:params})
+        if (!params.tableName) {
+            throw new Error(OINO_ERROR_PREFIX + ": OINODbApiParams needs to define a table name!")
+        }
+        this.db = db
+        this.params = params
+        this.datamodel = new OINODbDataModel(this)
+        if (this.params.hashidKey) {
+            this.hashid = new OINOHashid(this.params.hashidKey, this.db.name, this.params.hashidLength, this.params.hashidRandomIds)
+        } else {
+            this.hashid = null
+        }
+    }
+
+    private _validateRowValues(httpResult:OINODbApiResult, row:OINODataRow, requirePrimaryKey:boolean):void {
+        let field:OINODbDataField
+        for (let i=0; i<this.datamodel.fields.length; i++) {
+            field = this.datamodel.fields[i]
+            // OINOLog.debug("OINODbApi.validateHttpValues", {field:field})
+            const val:OINODataCell = row[i]
+            // OINOLog.debug("OINODbApi.validateHttpValues", {val:val})
+            if ((val === null) && ((field.fieldParams.isNotNull)||(field.fieldParams.isPrimaryKey))) { // null is a valid SQL value except if it's not allowed
+                httpResult.setError(405, "Field '" + field.name + "' is not allowed to be NULL!", "ValidateRowValues")
+
+            } else if ((val === undefined) && (requirePrimaryKey) && (field.fieldParams.isPrimaryKey) && (!field.fieldParams.isAutoInc)) { 
+                httpResult.setError(405, "Primary key '" + field.name + "' is not autoinc and missing from the data!", "ValidateRowValues")
+
+            } else if ((val !== undefined) && (this.params.failOnUpdateOnAutoinc) && (field.fieldParams.isAutoInc)) { 
+                httpResult.setError(405, "Autoinc field '" + field.name + "' can't be updated!", "ValidateRowValues")
+
+            } else {
+                if ((field instanceof OINOStringDataField) && ((field.maxLength > 0))){
+                    const str_val = val?.toString() || ""
+                    // OINOLog.debug("OINODbApi.validateHttpValues", {f:str_field, val:val})
+                    if (str_val.length > field.maxLength) {
+                        if (this.params.failOnOversizedValues) {
+                            httpResult.setError(405, "Field '" + field.name + "' length (" + str_val.length + ") exceeds maximum (" + field.maxLength + ") and can't be set!", "ValidateRowValues")
+                        } else {
+                            httpResult.addWarning("Field '" + field.name + "' length (" + str_val.length + ") exceeds maximum (" + field.maxLength + ") and might truncate or fail.", "ValidateRowValues")
+                        }
+                    }
+                }
+
+            }
+        }
+        //logDebug("OINODbApi.validateHttpValues", {result:result})
+    }
+
+    private async _doGet(result:OINODbApiResult, id:string, params:OINORequestParams):Promise<void> {
+        OINOBenchmark.start("doGet")
+        const sql:string = this.datamodel.printSqlSelect(id, params.sqlParams)
+        // OINOLog.debug("OINODbApi.doGet sql", {sql:sql})
+        try {
+            const sql_res:OINODbDataSet = await this.db.sqlSelect(sql)
+            // OINOLog.debug("OINODbApi.doGet sql_res", {sql_res:sql_res})
+            if (sql_res.hasErrors()) {
+                result.setError(500, sql_res.getFirstError(), "DoGet")
+                result.addDebug("OINO GET SQL [" + sql + "]", "DoPut")
+            } else {
+                result.data = new OINODbModelSet(this.datamodel, sql_res)
+            }
+        } catch (e:any) {
+            result.setError(500, "Unhandled exception in doGet: " + e.message, "DoGet")
+            result.addDebug("OINO GET SQL [" + sql + "]", "DoGet")
+        }
+        OINOBenchmark.end("doGet")
+    }
+    
+    private async _doPost(result:OINODbApiResult, rows:OINODataRow[]):Promise<void> {
+        OINOBenchmark.start("doPost")
+        let sql:string = "" 
+        try {
+            let i:number = 0
+            while (i<rows.length) {
+                this._validateRowValues(result, rows[i], this.params.failOnInsertWithoutKey||false)
+                if (result.success) {
+                    sql += this.datamodel.printSqlInsert(rows[i]) 
+                }
+                result.setOk() // individual rows may fail and will just be messages in response similar to executing multiple sql statements
+                i++
+            }
+            if (sql == "") {
+                result.setError(405, "No valid rows for POST!", "DoPost")
+                result.addDebug("OINO POST DATA [" + rows.join("|") + "]", "DoPost")
+
+            } else {
+                // OINOLog.debug("OINODbApi.doPost sql", {sql:sql})
+                const sql_res:OINODbDataSet = await this.db.sqlExec(sql)
+                // OINOLog.debug("OINODbApi.doPost sql_res", {sql_res:sql_res})
+                if (sql_res.hasErrors()) {
+                    result.setError(500, sql_res.getFirstError(), "DoPost")
+                    result.addDebug("OINO POST MESSAGES [" + sql_res.messages.join('|') + "]", "DoPost")
+                    result.addDebug("OINO POST SQL [" + sql + "]", "DoPost")
+                }
+            }
+        } catch (e:any) {
+            result.setError(500, "Unhandled exception in doPost: " + e.message, "DoPost")
+            result.addDebug("OINO POST SQL [" + sql + "]", "DoPost")
+        }
+        OINOBenchmark.end("doPost")
+    }
+
+    private async _doPut(result:OINODbApiResult, id:string, row:OINODataRow):Promise<void> {
+        OINOBenchmark.start("doPut")
+        let sql:string = ""
+        try {
+            this._validateRowValues(result, row, false)
+            if (result.success) {
+                sql = this.datamodel.printSqlUpdate(id, row)
+                // OINOLog.debug("OINODbApi.doPut sql", {sql:sql})
+                const sql_res:OINODbDataSet = await this.db.sqlExec(sql)
+                // OINOLog.debug("OINODbApi.doPut sql_res", {sql_res:sql_res})
+                if (sql_res.hasErrors()) {
+                    result.setError(500, sql_res.getFirstError(), "DoPut")
+                    result.addDebug("OINO PUT MESSAGES [" + sql_res.messages.join('|') + "]", "DoPut")
+                    result.addDebug("OINO PUT SQL [" + sql + "]", "DoPut")
+                }
+            }
+        } catch (e:any) {
+            result.setError(500, "Unhandled exception: " + e.message, "DoPut")
+            result.addDebug("OINO POST SQL [" + sql + "]", "DoPut")
+        }
+        OINOBenchmark.end("doPut")
+    }
+
+    private async _doDelete(result:OINODbApiResult, id:string):Promise<void> {
+        OINOBenchmark.start("doDelete")
+        let sql:string = ""
+        try {
+            sql = this.datamodel.printSqlDelete(id)
+            // OINOLog.debug("OINODbApi.doDelete sql", {sql:sql})
+            const sql_res:OINODbDataSet = await this.db.sqlExec(sql)
+            // OINOLog.debug("OINODbApi.doDelete sql_res", {sql_res:sql_res})
+            if (sql_res.hasErrors()) {
+                result.setError(500, sql_res.getFirstError(), "DoDelete")
+                result.addDebug("OINO DELETE MESSAGES [" + sql_res.messages.join('|') + "]", "DoDelete")
+                result.addDebug("OINO DELETE SQL [" + sql + "]", "DoDelete")
+            }
+        } catch (e:any) {
+            result.setError(500, "Unhandled exception: " + e.message, "DoDelete")
+            result.addDebug("OINO DELETE SQL [" + sql + "]", "DoDelete")
+        }
+        OINOBenchmark.end("doDelete")
+    }
+
+    /**
+     * Method for handlind a HTTP REST request with GET, POST, PUT, DELETE corresponding to
+     * SQL select, insert, update and delete.
+     * 
+     * @param method HTTP verb (uppercase)
+     * @param id URL id of the REST request
+     * @param body HTTP body data as string
+     * @param params HTTP URL parameters as key-value-pairs
+     *
+     */
+    async doRequest(method:string, id: string, body:string, params:OINORequestParams):Promise<OINODbApiResult> {
+        OINOBenchmark.start("doRequest")
+        let result:OINODbApiResult = new OINODbApiResult()
+        OINOLog.debug("OINODbApi.doRequest enter", {method:method, id:id, body:body, searchParams:params})
+        if (method == "GET") {
+            await this._doGet(result, id, params)
+    
+        } else if (method == "PUT") {
+            const rows:OINODataRow[] = OINODbFactory.createRows(this.datamodel, body, params)
+            if (!id) {
+                result.setError(400, "HTTP PUT method requires an URL ID for the row that is updated!", "DoRequest")
+
+            } else if (rows.length != 1) {
+                result.setError(400, "HTTP PUT method requires exactly one row in the body data!", "DoRequest")
+    
+            } else {
+                try {
+                    await this._doPut(result, id, rows[0])
+
+                } catch (e:any) {
+                    result.setError(500, "Unhandled exception in HTTP PUT doRequest: " + e.message, "DoRequest")
+                }             
+            }
+        } else if (method == "POST") {
+            const rows:OINODataRow[] = OINODbFactory.createRows(this.datamodel, body, params)
+            if (id) {
+                result.setError(400, "HTTP POST method must not have an URL ID as it does not target an existing row but creates a new one!", "DoRequest")
+
+            } else if (rows.length == 0)  {
+                result.setError(400, "HTTP POST method requires at least one row in the body data!", "DoRequest")
+
+            } else {
+                try {
+                    OINOLog.debug("OINODbApi.doRequest / POST", {rows:rows})
+                    await this._doPost(result, rows)
+
+                } catch (e:any) {
+                    result.setError(500, "Unhandled exception in HTTP POST doRequest: " + e.message, "DoRequest")
+                }
+            }
+        } else if (method == "DELETE") {
+            if (!id)  {
+                result.setError(400, "HTTP DELETE method requires an id!", "DoRequest")
+
+            } else {
+                try {
+                    await this._doDelete(result, id)
+
+                } catch (e:any) {
+                    result.setError(500, "Unhandled exception in HTTP DELETE doRequest: " + e.message, "DoRequest")
+                }
+            }
+        } else {
+            result.setError(405, "Unsupported HTTP method '" + method + "'", "DoRequest")
+        }
+        OINOBenchmark.end("doRequest")
+        return result
+    }
+}