@oino-ts/db 0.21.2 → 1.0.0

package/src/OINODbApi.ts

@@ -1,668 +1,390 @@
-/*
- * 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 { Buffer } from "node:buffer";
-import { OINOLog, OINOResult, OINOHttpRequest, type OINOHttpRequestInit, OINOBenchmark, OINOHttpResult, OINOHtmlTemplate, OINOContentType, OINO_ERROR_PREFIX } from "@oino-ts/common";
-import { OINODbApiParams, OINODb, OINODbDataSet, OINODbDataModel, OINODbDataField, OINOStringDataField, OINODataRow, OINODataCell, OINODbModelSet, OINODbConfig, OINONumberDataField, OINODbParser, OINODatetimeDataField, OINODbSqlParams, OINODbSqlAggregate, OINODbSqlSelect, OINODbSqlFilter, OINODbSqlOrder, OINODbSqlLimit, OINODbSqlBooleanOperation } from "./index.js"
-import { OINOHashid } from "@oino-ts/hashid"
-
-export type OINODbApiData = string|OINODataRow[]|Buffer|Uint8Array|object|null
-
-export interface OINODbApiRequestInit extends OINOHttpRequestInit {
-    rowId?: string
-    rowData?: OINODbApiData
-    sqlParams?: OINODbSqlParams
-    filter?: OINODbSqlFilter|string
-    order?: OINODbSqlOrder|string
-    limit?: OINODbSqlLimit|string
-    aggregate?: OINODbSqlAggregate|string
-    select?: OINODbSqlSelect|string
-}
-
-export class OINODbApiRequest extends OINOHttpRequest {
-    rowId:string
-    rowData:OINODbApiData
-    sqlParams:OINODbSqlParams
-
-    constructor (init: OINODbApiRequestInit) {
-        super(init)
-        this.rowId = init?.rowId || ""
-        this.rowData = init?.rowData || null // rowData is not compatible with OINOHttpRequest body so it's not automatically set, caller can set both if needed
-        this.sqlParams = init?.sqlParams || {}
-
-        if (init?.filter) {
-            if (init.filter instanceof OINODbSqlFilter) {
-                this.sqlParams.filter = init.filter
-            } else {
-                this.sqlParams.filter = OINODbSqlFilter.parse(init.filter)
-            }
-        } 
-        if (!this.sqlParams.filter) {
-            const filter_params = this.url?.searchParams.getAll(OINODbConfig.OINODB_SQL_FILTER_PARAM) || []
-            for (let i=0; i<filter_params.length; i++) {
-                const f = OINODbSqlFilter.parse(filter_params[i])
-                if (i > 0) {
-                    this.sqlParams.filter = OINODbSqlFilter.combine(this.sqlParams.filter, OINODbSqlBooleanOperation.and, f)
-                } else {
-                    this.sqlParams.filter = f
-                }
-            }
-        }
-        if (init?.order) {
-            if (init.order instanceof OINODbSqlOrder) {
-                this.sqlParams.order = init.order
-            } else {
-                this.sqlParams.order = OINODbSqlOrder.parse(init.order)
-            }
-        } 
-        if (!this.sqlParams.order) {
-            const order_param = this.url?.searchParams.get(OINODbConfig.OINODB_SQL_ORDER_PARAM)
-            if (order_param) {
-                this.sqlParams.order = OINODbSqlOrder.parse(order_param)
-            }
-        }
-        if (init?.limit) {
-            if (init.limit instanceof OINODbSqlLimit) {
-                this.sqlParams.limit = init.limit
-            } else {
-                this.sqlParams.limit = OINODbSqlLimit.parse(init.limit)
-            }
-        } 
-        if (!this.sqlParams.limit) {
-            const limit_param = this.url?.searchParams.get(OINODbConfig.OINODB_SQL_LIMIT_PARAM)
-            if (limit_param) {
-                this.sqlParams.limit = OINODbSqlLimit.parse(limit_param)
-            }
-        }
-        if (init?.aggregate) {
-            if (init.aggregate instanceof OINODbSqlAggregate) {
-                this.sqlParams.aggregate = init.aggregate
-            } else {
-                this.sqlParams.aggregate = OINODbSqlAggregate.parse(init.aggregate)
-            }
-        } 
-        if (!this.sqlParams.aggregate) {
-            const aggregate_param = this.url?.searchParams.get(OINODbConfig.OINODB_SQL_AGGREGATE_PARAM)
-            if (aggregate_param) {
-                this.sqlParams.aggregate = OINODbSqlAggregate.parse(aggregate_param)
-            }
-        }
-        if (init?.select) {
-            if (init.select instanceof OINODbSqlSelect) {
-                this.sqlParams.select = init.select
-            } else {
-                this.sqlParams.select = OINODbSqlSelect.parse(init.select)
-            }
-        } 
-        if (!this.sqlParams.select) {
-            const select_param = this.url?.searchParams.get(OINODbConfig.OINODB_SQL_SELECT_PARAM)
-            if (select_param) {
-                this.sqlParams.select = OINODbSqlSelect.parse(select_param)
-            }
-        }
-    }
-    static async fromFetchRequest(request: Request, rowId?: string, rowData?: OINODbApiData, sqlParams?: OINODbSqlParams): Promise<OINODbApiRequest> {
-        return new OINODbApiRequest({
-            url: new URL(request.url),
-            method: request.method,
-            headers: Object.fromEntries(request.headers as any),
-            rowId: rowId,
-            rowData: rowData ?? Buffer.from(await request.arrayBuffer()),
-            sqlParams: sqlParams
-        })
-    }
-
-    static fromHttpRequest(request: OINOHttpRequest, rowId?: string, rowData?: OINODbApiData, sqlParams?: OINODbSqlParams): OINODbApiRequest {
-        return new OINODbApiRequest({
-            url: typeof request.url === "string" ? new URL(request.url) : request.url,
-            method: request.method,
-            headers: Object.fromEntries(request.headers as any),
-            rowId: rowId,
-            rowData: rowData ?? request.bodyAsBuffer(),
-            requestType: request.requestType,
-            responseType: request.responseType,
-            multipartBoundary: request.multipartBoundary,
-            lastModified: request.lastModified,
-            sqlParams: sqlParams
-        })
-    }
-}
-
-/**
- * OINO API request result object with returned data and/or http status code/message and 
- * error / warning messages.
- *
- */
-export class OINODbApiResult extends OINOResult {
-    /** DbApi request params */
-    request: OINODbApiRequest
-
-    /** Returned data if any */
-    data?: OINODbModelSet;
-
-    /**
-     * Constructor of OINODbApiResult.
-     * 
-     * @param request DbApi request parameters
-     * @param data result data
-     *
-     */
-    constructor (request:OINODbApiRequest, data?:OINODbModelSet) {
-        super()
-        this.request = request
-        this.data = data
-    }
-
-    /**
-     * Creates a HTTP Response from API results.
-     *
-     * @param headers Headers to include in the response
-     * 
-     */
-    async writeApiResponse(headers:Record<string, string> = {}):Promise<Response> {
-        let response:Response|null = null
-        if (this.success && this.data) {
-            const body = await this.data.writeString(this.request.responseType)
-            response = new Response(body, {status:this.status, statusText: this.statusText, headers: headers })
-        } else {
-            response = new Response(JSON.stringify(this, null, 3), {status:this.status, statusText: this.statusText, headers: headers })
-        }
-        for (let i=0; i<this.messages.length; i++) {
-            response.headers.set('X-OINO-MESSAGE-' + i, this.messages[i])
-        }         
-        return Promise.resolve(response)
-    }
-}
-
-/**
- * Specialized HTML template that can render ´OINODbApiResult´.
- *
- */
-export class OINODbHtmlTemplate extends OINOHtmlTemplate {
-    /** Locale validation regex */
-    static LOCALE_REGEX:RegExp = /^(\w\w)(\-\w\w)?$/
-    /** Locale formatter */
-    protected _locale:Intl.DateTimeFormat|null
-    protected _numberDecimals:number = -1
-
-    /**
-     * Constructor of OINODbHtmlTemplate.
-     *
-     * @param template HTML template string
-     * @param numberDecimals Number of decimals to use for numbers, -1 for no formatting
-     * @param dateLocaleStr Datetime format string, either "iso" for ISO8601 or "default" for system default or valid locale string
-     * @param dateLocaleStyle Datetime format style, either "short/medium/long/full" or Intl.DateTimeFormat options
-     * 
-     */
-    constructor (template:string, numberDecimals:number=-1, dateLocaleStr:string="", dateLocaleStyle:string|any="") {
-        super(template)
-        let locale_opts:any
-        if ((dateLocaleStyle == null) || (dateLocaleStyle == "")) {
-            locale_opts = { dateStyle: "medium", timeStyle: "medium" }
-        } else if (typeof dateLocaleStyle == "string") {
-            locale_opts = { dateStyle: dateLocaleStyle, timeStyle: dateLocaleStyle }
-        } else {
-            locale_opts = dateLocaleStyle
-        }
-        this._locale = null
-        this._numberDecimals = numberDecimals
-
-        if ((dateLocaleStr != null) && (dateLocaleStr != "") && OINODbHtmlTemplate.LOCALE_REGEX.test(dateLocaleStr)) {
-            try {
-                this._locale = new Intl.DateTimeFormat(dateLocaleStr, locale_opts)
-            } catch (e:any) {}
-        }
-    }
-
-    /**
-     * Creates HTML Response from API modelset.
-     *
-     * @param modelset OINO API dataset
-     * @param overrideValues values to override in the data
-     * 
-     */
-    async renderFromDbData(modelset:OINODbModelSet, overrideValues?:any):Promise<OINOHttpResult> {
-        OINOBenchmark.startMetric("OINOHtmlTemplate", "renderFromDbData")
-        let html:string = ""
-        const dataset:OINODbDataSet|undefined = modelset.dataset
-        const datamodel:OINODbDataModel = modelset.datamodel
-        const api:OINODbApi = modelset.datamodel.api
-        const modified_index = datamodel.findFieldIndexByName(api.params.cacheModifiedField || "")
-        let last_modified:number = this.modified
-        
-        while (!dataset.isEof()) {
-            const row:OINODataRow = dataset.getRow()
-            if (modified_index >= 0) {
-                last_modified = Math.max(last_modified, new Date(row[modified_index] as Date).getTime())
-            }
-            let row_id_seed:string = datamodel.getRowPrimarykeyValues(row).join(' ')
-            let primary_key_values:string[] = []
-            this.clearVariables()
-            this.setVariableFromValue(OINODbConfig.OINODB_ID_FIELD, "")
-            for (let i=0; i<datamodel.fields.length; i++) {
-                const f:OINODbDataField = datamodel.fields[i]
-                let value:string|null|undefined 
-                if ((f instanceof OINODatetimeDataField) && (this._locale != null)) {
-                    value = f.serializeCellWithLocale(row[i], this._locale)
-
-                } else if ((f instanceof OINONumberDataField) && (this._numberDecimals >= 0) && (typeof row[i] === "number")) {
-                    // console.debug("renderFromDbData number decimals", { field: f.name, value: row[i], type: typeof row[i] });
-                    value = (row[i]! as number).toFixed(this._numberDecimals)
-
-                } else {
-                    value = f.serializeCell(row[i])
-                }
-                if (f.fieldParams.isPrimaryKey || f.fieldParams.isForeignKey) {
-                    if (value && (f instanceof OINONumberDataField) && (datamodel.api.hashid)) {
-                        value = datamodel.api.hashid.encode(value, f.name + " " + row_id_seed)
-                    }
-                    if (f.fieldParams.isPrimaryKey) {
-                        primary_key_values.push(value || "")
-                    }
-                }
-                this.setVariableFromValue(f.name, value || "")
-            }
-            this.setVariableFromProperties(overrideValues)
-            this.setVariableFromValue(OINODbConfig.OINODB_ID_FIELD, OINODbConfig.printOINOId(primary_key_values))
-            html += this._renderHtml() + "\r\n"
-            await dataset.next()
-        }
-        this.modified = last_modified
-        const result:OINOHttpResult = this._createHttpResult(html)
-        OINOBenchmark.endMetric("OINOHtmlTemplate", "renderFromDbData")
-        return result
-    }
-
-}
-
-
-/**
- * API class with method to process HTTP REST requests.
- *
- */
-export class OINODbApi {
-    /** Enable debug output on errors */
-    private _debugOnError:boolean = false
-
-    /** 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) {
-        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.hashidStaticIds)
-        } else {
-            this.hashid = null
-        }
-    }
-
-    private _validateRow(result:OINODbApiResult, row:OINODataRow, requirePrimaryKey:boolean):void {
-        let field:OINODbDataField
-        for (let i=0; i<this.datamodel.fields.length; i++) {
-            field = this.datamodel.fields[i]
-            const val:OINODataCell = row[i]
-            if ((val === null) && ((field.fieldParams.isNotNull)||(field.fieldParams.isPrimaryKey))) { // null is a valid SQL value except if it's not allowed
-                result.setError(405, "Field '" + field.name + "' is not allowed to be NULL!", "ValidateRowValues")
-
-            } else if ((val === undefined) && (requirePrimaryKey) && (field.fieldParams.isPrimaryKey) && (!field.fieldParams.isAutoInc)) { 
-                result.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)) { 
-                result.setError(405, "Autoinc field '" + field.name + "' can't be updated!", "ValidateRowValues")
-
-            } else {
-                if ((field instanceof OINOStringDataField) && ((field.maxLength > 0))){
-                    const str_val = val?.toString() || ""
-                    if (str_val.length > field.maxLength) {
-                        if (this.params.failOnOversizedValues) {
-                            result.setError(405, "Field '" + field.name + "' length (" + str_val.length + ") exceeds maximum (" + field.maxLength + ") and can't be set!", "ValidateRowValues")
-                        } else {
-                            result.addWarning("Field '" + field.name + "' length (" + str_val.length + ") exceeds maximum (" + field.maxLength + ") and might truncate or fail.", "ValidateRowValues")
-                        }
-                    }
-                }
-
-            }
-        }
-        //logDebug("OINODbApi.validateHttpValues", {result:result})
-    }
-
-    private _parseData(httpResult:OINODbApiResult, request:OINODbApiRequest):OINODataRow[] {
-        let rows:OINODataRow[] = []
-        const data = request.rowData ?? request.body
-        try {
-            if (Array.isArray(data)) {
-                rows = data as OINODataRow[]
-            } else if (data != null) {
-                rows = OINODbParser.createRows(this.datamodel, data, request.requestType, request.multipartBoundary)
-            }
-        
-        } catch (e:any) {
-            httpResult.setError(400, "Invalid data: " + e.message, "DoRequest")
-        }
-        return rows
-    }
-
-    private async _doGet(result:OINODbApiResult, rowId:string, request:OINODbApiRequest):Promise<void> {
-        let sql:string = ""
-        try {
-            sql = this.datamodel.printSqlSelect(rowId, request.sqlParams || {})
-            OINOLog.debug("@oino-ts/db", "OINODbApi", "_doGet", "Print SQL", {sql:sql})
-            const sql_res:OINODbDataSet = await this.db.sqlSelect(sql)
-            if (sql_res.success == false) {
-                result.setError(500, sql_res.statusText, "DoGet")
-                if (this._debugOnError) {
-                    result.addDebug("OINO GET SQL [" + sql + "]", "DoPut")
-                }
-            } else {
-                result.data = new OINODbModelSet(this.datamodel, sql_res, request.sqlParams)
-            }
-        } catch (e:any) {
-            result.setError(500, "Unhandled exception in doGet: " + e.message, "DoGet")
-            OINOLog.exception("@oino-ts/db", "OINODbApi", "_doGet", "exception in get request", {message:e.message, stack:e.stack})
-            if (this._debugOnError) {
-                result.addDebug("OINO GET SQL [" + sql + "]", "DoGet")
-            }
-        }
-    }
-    
-    private async _doPost(result:OINODbApiResult, rows:OINODataRow[], request:OINODbApiRequest):Promise<void> {
-        let sql:string = "" 
-        try {
-            for (let i=0; i<rows.length; i++) {
-                this._validateRow(result, rows[i], this.params.failOnInsertWithoutKey||false)
-                if (result.success) {
-                    sql += this.datamodel.printSqlInsert(rows[i]) 
-
-                } else if (this.params.failOnAnyInvalidRows == false) {
-                    result.setOk() // individual rows may fail and will just be messages in response similar to executing multiple sql statements
-                }
-            }
-            if ((sql == "") && result.success) {
-                result.setError(405, "No valid rows for POST!", "DoPost")
-
-            } else if (result.success) {
-                OINOLog.debug("@oino-ts/db", "OINODbApi", "_doPost", "Print SQL", {sql:sql})
-                const sql_res:OINODbDataSet = await this.db.sqlExec(sql)
-                if (sql_res.success == false) {
-                    result.setError(500, sql_res.statusText, "DoPost")
-                    if (this._debugOnError) {
-                        result.addDebug("OINO POST MESSAGES [" + sql_res.statusText + "]", "DoPost")
-                        result.addDebug("OINO POST SQL [" + sql + "]", "DoPost")                
-                    }
-                } else if (this.params.returnInsertedIds) {
-                    result.data = new OINODbModelSet(this.datamodel, sql_res, request.sqlParams) // return the inserted ids as data
-                }
-            }
-        } catch (e:any) {
-            result.setError(500, "Unhandled exception in doPost: " + e.message, "DoPost")
-            OINOLog.exception("@oino-ts/db", "OINODbApi", "_doPost", "exception in post request", {message:e.message, stack:e.stack})
-            if (this._debugOnError) {
-                result.addDebug("OINO POST SQL [" + sql + "]", "DoPost")
-            }
-        }
-    }
-
-    private async _doPut(result:OINODbApiResult, id:string|null, rows:OINODataRow[]):Promise<void> {
-        let sql:string = ""
-        try {
-            // this._validateRowValues(result, row, false)
-            for (let i=0; i<rows.length; i++) {
-                const row_id = id || OINODbConfig.printOINOId(this.datamodel.getRowPrimarykeyValues(rows[i], this.hashid != null))
-                this._validateRow(result, rows[i], this.params.failOnInsertWithoutKey||false)
-                if (result.success) {
-                    sql += this.datamodel.printSqlUpdate(row_id, rows[i]) 
-
-                } else if (this.params.failOnAnyInvalidRows == false) {
-                    result.setOk() // individual rows may fail and will just be messages in response similar to executing multiple sql statements
-                }
-            }
-            if ((sql == "") && result.success) {
-                result.setError(405, "No valid rows for PUT!", "DoPut") // only set error if there are multiple rows and no valid sql was created
-
-            } else if (result.success) {
-                OINOLog.debug("@oino-ts/db", "OINODbApi", "_doPut", "Print SQL", {sql:sql})
-                const sql_res:OINODbDataSet = await this.db.sqlExec(sql)
-                if (sql_res.success == false) {
-                    result.setError(500, sql_res.statusText, "DoPut")
-                    if (this._debugOnError) {
-                        result.addDebug("OINO PUT MESSAGES [" + sql_res.statusText + "]", "DoPut")
-                        result.addDebug("OINO PUT SQL [" + sql + "]", "DoPut")
-                    }
-                }
-            }
-        } catch (e:any) {
-            result.setError(500, "Unhandled exception: " + e.message, "DoPut")
-            OINOLog.exception("@oino-ts/db", "OINODbApi", "_doPut", "exception in put request", {message:e.message, stack:e.stack})
-            if (this._debugOnError) {
-                result.addDebug("OINO PUT SQL [" + sql + "]", "DoPut")
-            }
-        }
-    }
-
-    private async _doDelete(result:OINODbApiResult, id:string|null, rows:OINODataRow[]|null):Promise<void> {
-        let sql:string = ""
-        try {
-            if (rows != null) {
-                for (let i=0; i<rows.length; i++) {
-                    const row_id = OINODbConfig.printOINOId(this.datamodel.getRowPrimarykeyValues(rows[i], this.hashid != null))
-                    if (row_id) {
-                        sql += this.datamodel.printSqlDelete(row_id) 
-                    } else if (this.params.failOnAnyInvalidRows == false) {
-                        result.setOk() // individual rows may fail and will just be messages in response similar to executing multiple sql statements
-                    }
-                }
-            } else if (id) {
-                sql = this.datamodel.printSqlDelete(id)
-            }
-            if ((sql == "") && result.success) {
-                result.setError(405, "No valid rows for DELETE!", "DoDelete") // only set error if there are multiple rows and no valid sql was created
-
-            } else if (result.success) {
-            
-                OINOLog.debug("@oino-ts/db", "OINODbApi", "_doDelete", "Print SQL", {sql:sql})
-                const sql_res:OINODbDataSet = await this.db.sqlExec(sql)
-                if (sql_res.success == false) {
-                    result.setError(500, sql_res.statusText, "DoDelete")
-                    if (this._debugOnError) {
-                        result.addDebug("OINO DELETE MESSAGES [" + sql_res.statusText + "]", "DoDelete")
-                        result.addDebug("OINO DELETE SQL [" + sql + "]", "DoDelete")                    
-                    }
-                }
-            }
-        } catch (e:any) {
-            result.setError(500, "Unhandled exception: " + e.message, "DoDelete")
-            OINOLog.exception("@oino-ts/db", "OINODbApi", "_doDelete", "exception in delete request", {message:e.message, stack:e.stack})
-            if (this._debugOnError) {
-                result.addDebug("OINO DELETE SQL [" + sql + "]", "DoDelete")
-            }
-        }
-    }
-
-    /**
-     * Enable or disable debug output on errors.
-     * 
-     * @param debugOnError true to enable debug output on errors, false to disable
-     */
-    setDebugOnError(debugOnError:boolean) {
-        this._debugOnError = debugOnError
-    }
-
-    /**
-     * Method for handling a HTTP REST request with GET, POST, PUT, DELETE corresponding to
-     * SQL select, insert, update and delete.
-     * 
-     * @param request OINO HTTP request object containing all parameters of the REST request
-     * @param rowId URL id of the REST request
-     * @param rowData HTTP body data as either serialized string or unserialized JS object or OINODataRow-array or Buffer/Uint8Array binary data
-     * @param sqlParams SQL parameters for the REST request
-     *
-     */
-    async doHttpRequest(request: OINOHttpRequest, rowId:string, rowData:OINODbApiData, sqlParams:OINODbSqlParams):Promise<OINODbApiResult> {
-        const api_request = OINODbApiRequest.fromHttpRequest(request, rowId, rowData, sqlParams)
-        return this.doApiRequest(api_request)
-    }
-    /**
-     * Method for handling a HTTP REST request with GET, POST, PUT, DELETE corresponding to
-     * SQL select, insert, update and delete.
-     * 
-     * @param method HTTP method of the REST request
-     * @param rowId URL id of the REST request
-     * @param rowData HTTP body data as either serialized string or unserialized JS object or OINODataRow-array or Buffer/Uint8Array binary data
-     * @param sqlParams SQL parameters for the REST request
-     * @param contentType content type of the HTTP body data, default is JSON
-     *
-     */
-    async doRequest(method:string, rowId:string, rowData:OINODbApiData, sqlParams:OINODbSqlParams, contentType:OINOContentType = OINOContentType.json):Promise<OINODbApiResult> {
-        return this.doApiRequest(new OINODbApiRequest({method: method, rowId: rowId, rowData: rowData, sqlParams: sqlParams, requestType: contentType}))
-    }
-    
-    async doApiRequest(request:OINODbApiRequest):Promise<OINODbApiResult> {
-        OINOBenchmark.startMetric("OINODbApi", "doRequest." + request.method)
-        OINOLog.debug("@oino-ts/db", "OINODbApi", "doRequest", "Request", {method:request.method, id:request.rowId, data:request.rowData})
-        let result:OINODbApiResult = new OINODbApiResult(request)
-        let rows:OINODataRow[] = []
-        if ((request.method == "POST") || (request.method == "PUT")) {
-            rows = this._parseData(result, request)
-        }
-        if (request.method == "GET") {
-            await this._doGet(result, request.rowId, request)
-    
-        } else if (request.method == "PUT") {
-            if (!request.rowId) {
-                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, request.rowId, rows)
-
-                } catch (e:any) {
-                    result.setError(500, "Unhandled exception in HTTP PUT doRequest: " + e.message, "DoRequest")
-                }             
-            }
-        } else if (request.method == "POST") {
-            if (request.rowId) {
-                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 {
-                    await this._doPost(result, rows, request)
-
-                } catch (e:any) {
-                    result.setError(500, "Unhandled exception in HTTP POST doRequest: " + e.message, "DoRequest")
-                }
-            }
-        } else if (request.method == "DELETE") {
-            if (!request.rowId)  {
-                result.setError(400, "HTTP DELETE method requires an id!", "DoRequest")
-
-            } else {
-                try {
-                    await this._doDelete(result, request.rowId, null)
-
-                } catch (e:any) {
-                    result.setError(500, "Unhandled exception in HTTP DELETE doRequest: " + e.message, "DoRequest")
-                }
-            }
-        } else {
-            result.setError(405, "Unsupported HTTP method '" + request.method + "' for REST request", "DoRequest")
-        }
-        OINOBenchmark.endMetric("OINODbApi", "doRequest." + request.method, result.status != 500)
-        return Promise.resolve(result)
-    }
-
-    /**
-     * Method for handling a HTTP REST request with batch update using PUT or DELETE methods.
-     * 
-     * @param method HTTP method of the REST request
-     * @param rowId URL id of the REST request
-     * @param rowData HTTP body data as either serialized string or unserialized JS object or OINODataRow-array or Buffer/Uint8Array binary data
-     *
-     */
-    async doBatchUpdate(method:string, rowId:string, rowData:OINODbApiData, sqlParams?: OINODbSqlParams):Promise<OINODbApiResult> {
-        return this.doApiRequest(new OINODbApiRequest({ method: method, rowId: rowId, rowData: rowData, sqlParams: sqlParams }))
-    }
-    /**
-     * Method for handling a HTTP REST request with batch update using PUT or DELETE methods.
-     * 
-     * @param request HTTP URL parameters as key-value-pairs
-     *
-     */
-    async runBatchUpdate(request:OINODbApiRequest):Promise<OINODbApiResult> {
-        OINOLog.debug("@oino-ts/db", "OINODbApi", "doBatchUpdate", "Request", {request:request, data:request.rowData})
-        let result:OINODbApiResult = new OINODbApiResult(request)
-        if ((request.method != "PUT") && (request.method != "DELETE")) {
-            result.setError(500, "Batch update only supports PUT and DELETE methods!", "DoBatchUpdate")
-            return Promise.resolve(result)
-        }
-        OINOBenchmark.startMetric("OINODbApi", "doBatchUpdate." + request.method)
-        const rows:OINODataRow[] = [] = this._parseData(result, request)
-        if (request.method == "PUT") {
-
-            try {
-                await this._doPut(result, null, rows)
-
-            } catch (e:any) {
-                result.setError(500, "Unhandled exception in HTTP PUT doRequest: " + e.message, "DoBatchUpdate")
-            }             
-
-        } else if (request.method == "DELETE") {
-            try {
-                await this._doDelete(result, null, rows)
-
-            } catch (e:any) {
-                result.setError(500, "Unhandled exception in HTTP DELETE doRequest: " + e.message, "DoBatchUpdate")
-            }
-        }
-        OINOBenchmark.endMetric("OINODbApi", "doBatchUpdate." + request.method, result.status != 500)
-        return Promise.resolve(result)
-    }
-
-    /**
-     * Method to check if a field is included in the API params.
-     *
-     * @param fieldName name of the field
-     * 
-     */
-
-    public isFieldIncluded(fieldName:string):boolean {
-        const params = this.params
-        return (
-            ((params.excludeFieldPrefix == undefined) || (params.excludeFieldPrefix == "") || (fieldName.startsWith(params.excludeFieldPrefix) == false)) && 
-            ((params.excludeFields == undefined) || (params.excludeFields.length == 0) || (params.excludeFields.indexOf(fieldName) < 0)) &&
-            ((params.includeFields == undefined) || (params.includeFields.length == 0) || (params.includeFields.indexOf(fieldName) >= 0))
-        ) 
-    }
-
+/*
+ * 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 { OINOApi, OINOApiParams, OINOLog, OINOBenchmark, OINOHttpRequest, OINOHttpResult, OINOApiRequest, OINOApiResult, OINOHtmlTemplate, OINOContentType, OINODataRow, OINODataCell, OINODataSet, OINODataField, OINOStringDataField, OINOConfig, OINONumberDataField, OINODatetimeDataField, OINOQueryParams, OINOApiData, OINOModelSet, OINOParser, OINO_ERROR_PREFIX } from "@oino-ts/common";
+import { OINODb } from "./OINODb.js"
+import { OINODbDataModel } from "./OINODbDataModel.js"
+
+
+/**
+ * API class with method to process HTTP REST requests.
+ *
+ */
+export class OINODbApi extends OINOApi {
+    /** DB reference */
+    readonly db: OINODb
+
+    /** DB parameters reference */
+    readonly dbParams: OINOApiParams
+
+    /** DB datamodel reference */
+    dbDatamodel: OINODbDataModel|null = 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:OINOApiParams) {
+        super(db, params)
+        if (!params.tableName) {
+            throw new Error(OINO_ERROR_PREFIX + ": OINOApiParams needs to define a table name!")
+        }
+        this.db = db
+        this.dbParams = params
+
+    }
+
+    initializeDatamodel(datamodel: OINODbDataModel) {
+        this.dbDatamodel = datamodel
+        this.datamodel = datamodel
+        this.initialized = true
+    }
+
+    private _validateRow(result:OINOApiResult, row:OINODataRow, requirePrimaryKey:boolean):void {
+        let field:OINODataField
+        for (let i=0; i<this.dbDatamodel!.fields.length; i++) {
+            field = this.dbDatamodel!.fields[i]
+            const val:OINODataCell = row[i]
+            if ((val === null) && ((field.fieldParams.isNotNull)||(field.fieldParams.isPrimaryKey))) { // null is a valid SQL value except if it's not allowed
+                result.setError(405, "Field '" + field.name + "' is not allowed to be NULL!", "ValidateRowValues")
+
+            } else if ((val === undefined) && (requirePrimaryKey) && (field.fieldParams.isPrimaryKey) && (!field.fieldParams.isAutoInc)) { 
+                result.setError(405, "Primary key '" + field.name + "' is not autoinc and missing from the data!", "ValidateRowValues")
+
+            } else if ((val !== undefined) && (this.dbParams.failOnUpdateOnAutoinc) && (field.fieldParams.isAutoInc)) { 
+                result.setError(405, "Autoinc field '" + field.name + "' can't be updated!", "ValidateRowValues")
+
+            } else {
+                if ((field instanceof OINOStringDataField) && ((field.maxLength > 0))){
+                    const str_val = val?.toString() || ""
+                    if (str_val.length > field.maxLength) {
+                        if (this.dbParams.failOnOversizedValues) {
+                            result.setError(405, "Field '" + field.name + "' length (" + str_val.length + ") exceeds maximum (" + field.maxLength + ") and can't be set!", "ValidateRowValues")
+                        } else {
+                            result.addWarning("Field '" + field.name + "' length (" + str_val.length + ") exceeds maximum (" + field.maxLength + ") and might truncate or fail.", "ValidateRowValues")
+                        }
+                    }
+                }
+
+            }
+        }
+        //logDebug("OINODbApi.validateHttpValues", {result:result})
+    }
+
+    private _parseData(httpResult:OINOApiResult, request:OINOApiRequest):OINODataRow[] {
+        let rows:OINODataRow[] = []
+        const data = request.rowData ?? request.body
+        try {
+            if (Array.isArray(data)) {
+                rows = data as OINODataRow[]
+            } else if (data != null) {
+                rows = OINOParser.createRows(this.datamodel!, data, request.requestType, request.multipartBoundary)
+            }
+        
+        } catch (e:any) {
+            httpResult.setError(400, "Invalid data: " + e.message, "DoRequest")
+        }
+        return rows
+    }
+
+    private async _doGet(result:OINOApiResult, rowId:string, request:OINOApiRequest):Promise<void> {
+        let sql:string = ""
+        try {
+            sql = this.dbDatamodel!.printSqlSelect(rowId, request.queryParams || {})
+            OINOLog.debug("@oino-ts/db", "OINODbApi", "_doGet", "Print SQL", {sql:sql})
+            const sql_res:OINODataSet = await this.db.sqlSelect(sql)
+            if (sql_res.success == false) {
+                result.setError(500, sql_res.statusText, "DoGet")
+                if (this._debugOnError) {
+                    result.addDebug("OINO GET SQL [" + sql + "]", "DoPut")
+                }
+            } else {
+                result.data = new OINOModelSet(this.datamodel!, sql_res, request.queryParams)
+            }
+        } catch (e:any) {
+            result.setError(500, "Unhandled exception in doGet: " + e.message, "DoGet")
+            OINOLog.exception("@oino-ts/db", "OINODbApi", "_doGet", "exception in get request", {message:e.message, stack:e.stack})
+            if (this._debugOnError) {
+                result.addDebug("OINO GET SQL [" + sql + "]", "DoGet")
+            }
+        }
+    }
+    
+    private async _doPost(result:OINOApiResult, rows:OINODataRow[], request:OINOApiRequest):Promise<void> {
+        let sql:string = "" 
+        try {
+            for (let i=0; i<rows.length; i++) {
+                this._validateRow(result, rows[i], this.dbParams.failOnInsertWithoutKey||false)
+                if (result.success) {
+                    sql += this.dbDatamodel!.printSqlInsert(rows[i]) 
+
+                } else if (this.dbParams.failOnAnyInvalidRows == false) {
+                    result.setOk() // individual rows may fail and will just be messages in response similar to executing multiple sql statements
+                }
+            }
+            if ((sql == "") && result.success) {
+                result.setError(405, "No valid rows for POST!", "DoPost")
+
+            } else if (result.success) {
+                OINOLog.debug("@oino-ts/db", "OINODbApi", "_doPost", "Print SQL", {sql:sql})
+                const sql_res:OINODataSet = await this.db.sqlExec(sql)
+                if (sql_res.success == false) {
+                    result.setError(500, sql_res.statusText, "DoPost")
+                    if (this._debugOnError) {
+                        result.addDebug("OINO POST MESSAGES [" + sql_res.statusText + "]", "DoPost")
+                        result.addDebug("OINO POST SQL [" + sql + "]", "DoPost")                
+                    }
+                } else if (this.dbParams.returnInsertedIds) {
+                    result.data = new OINOModelSet(this.datamodel!, sql_res, request.queryParams) // return the inserted ids as data
+                }
+            }
+        } catch (e:any) {
+            result.setError(500, "Unhandled exception in doPost: " + e.message, "DoPost")
+            OINOLog.exception("@oino-ts/db", "OINODbApi", "_doPost", "exception in post request", {message:e.message, stack:e.stack})
+            if (this._debugOnError) {
+                result.addDebug("OINO POST SQL [" + sql + "]", "DoPost")
+            }
+        }
+    }
+
+    private async _doPut(result:OINOApiResult, id:string|null, rows:OINODataRow[]):Promise<void> {
+        let sql:string = ""
+        try {
+            // this._validateRowValues(result, row, false)
+            for (let i=0; i<rows.length; i++) {
+                const row_id = id || OINOConfig.printOINOId(this.dbDatamodel!.getRowPrimarykeyValues(rows[i], this.hashid != null))
+                this._validateRow(result, rows[i], this.dbParams.failOnInsertWithoutKey||false)
+                if (result.success) {
+                    sql += this.dbDatamodel!.printSqlUpdate(row_id, rows[i]) 
+
+                } else if (this.dbParams.failOnAnyInvalidRows == false) {
+                    result.setOk() // individual rows may fail and will just be messages in response similar to executing multiple sql statements
+                }
+            }
+            if ((sql == "") && result.success) {
+                result.setError(405, "No valid rows for PUT!", "DoPut") // only set error if there are multiple rows and no valid sql was created
+
+            } else if (result.success) {
+                OINOLog.debug("@oino-ts/db", "OINODbApi", "_doPut", "Print SQL", {sql:sql})
+                const sql_res:OINODataSet = await this.db.sqlExec(sql)
+                if (sql_res.success == false) {
+                    result.setError(500, sql_res.statusText, "DoPut")
+                    if (this._debugOnError) {
+                        result.addDebug("OINO PUT MESSAGES [" + sql_res.statusText + "]", "DoPut")
+                        result.addDebug("OINO PUT SQL [" + sql + "]", "DoPut")
+                    }
+                }
+            }
+        } catch (e:any) {
+            result.setError(500, "Unhandled exception: " + e.message, "DoPut")
+            OINOLog.exception("@oino-ts/db", "OINODbApi", "_doPut", "exception in put request", {message:e.message, stack:e.stack})
+            if (this._debugOnError) {
+                result.addDebug("OINO PUT SQL [" + sql + "]", "DoPut")
+            }
+        }
+    }
+
+    private async _doDelete(result:OINOApiResult, id:string|null, rows:OINODataRow[]|null):Promise<void> {
+        let sql:string = ""
+        try {
+            if (rows != null) {
+                for (let i=0; i<rows.length; i++) {
+                    const row_id = OINOConfig.printOINOId(this.dbDatamodel!.getRowPrimarykeyValues(rows[i], this.hashid != null))
+                    if (row_id) {
+                        sql += this.dbDatamodel!.printSqlDelete(row_id) 
+                    } else if (this.dbParams.failOnAnyInvalidRows == false) {
+                        result.setOk() // individual rows may fail and will just be messages in response similar to executing multiple sql statements
+                    }
+                }
+            } else if (id) {
+                sql = this.dbDatamodel!.printSqlDelete(id)
+            }
+            if ((sql == "") && result.success) {
+                result.setError(405, "No valid rows for DELETE!", "DoDelete") // only set error if there are multiple rows and no valid sql was created
+
+            } else if (result.success) {
+            
+                OINOLog.debug("@oino-ts/db", "OINODbApi", "_doDelete", "Print SQL", {sql:sql})
+                const sql_res:OINODataSet = await this.db.sqlExec(sql)
+                if (sql_res.success == false) {
+                    result.setError(500, sql_res.statusText, "DoDelete")
+                    if (this._debugOnError) {
+                        result.addDebug("OINO DELETE MESSAGES [" + sql_res.statusText + "]", "DoDelete")
+                        result.addDebug("OINO DELETE SQL [" + sql + "]", "DoDelete")                    
+                    }
+                }
+            }
+        } catch (e:any) {
+            result.setError(500, "Unhandled exception: " + e.message, "DoDelete")
+            OINOLog.exception("@oino-ts/db", "OINODbApi", "_doDelete", "exception in delete request", {message:e.message, stack:e.stack})
+            if (this._debugOnError) {
+                result.addDebug("OINO DELETE SQL [" + sql + "]", "DoDelete")
+            }
+        }
+    }
+
+    /**
+     * Method for handling a HTTP REST request with GET, POST, PUT, DELETE corresponding to
+     * SQL select, insert, update and delete.
+     * 
+     * @param request OINO HTTP request object containing all parameters of the REST request
+     * @param rowId URL id of the REST request
+     * @param rowData HTTP body data as either serialized string or unserialized JS object or OINODataRow-array or Buffer/Uint8Array binary data
+     * @param queryParams SQL parameters for the REST request
+     *
+     */
+    async doHttpRequest(request: OINOHttpRequest, rowId:string, rowData:OINOApiData, queryParams:OINOQueryParams):Promise<OINOApiResult> {
+        const api_request = OINOApiRequest.fromHttpRequest(request, rowId, rowData, queryParams)
+        return this.doApiRequest(api_request)
+    }
+    /**
+     * Method for handling a HTTP REST request with GET, POST, PUT, DELETE corresponding to
+     * SQL select, insert, update and delete.
+     * 
+     * @param method HTTP method of the REST request
+     * @param rowId URL id of the REST request
+     * @param rowData HTTP body data as either serialized string or unserialized JS object or OINODataRow-array or Buffer/Uint8Array binary data
+     * @param queryParams SQL parameters for the REST request
+     * @param contentType content type of the HTTP body data, default is JSON
+     *
+     */
+    async doRequest(method:string, rowId:string, rowData:OINOApiData, queryParams:OINOQueryParams, contentType:OINOContentType = OINOContentType.json):Promise<OINOApiResult> {
+        return this.doApiRequest(new OINOApiRequest({method: method, rowId: rowId, rowData: rowData, queryParams: queryParams, requestType: contentType}))
+    }
+    
+    async doApiRequest(request:OINOApiRequest):Promise<OINOApiResult> {
+        if (this.initialized == false) {
+            throw new Error(OINO_ERROR_PREFIX + ": API is not initialized yet!")
+        }
+        OINOBenchmark.startMetric("OINODbApi", "doRequest." + request.method)
+        OINOLog.debug("@oino-ts/db", "OINODbApi", "doRequest", "Request", {method:request.method, id:request.rowId, data:request.rowData})
+        let result:OINOApiResult = new OINOApiResult(request)
+        let rows:OINODataRow[] = []
+        if ((request.method == "POST") || (request.method == "PUT")) {
+            rows = this._parseData(result, request)
+        }
+        if (request.method == "GET") {
+            await this._doGet(result, request.rowId, request)
+    
+        } else if (request.method == "PUT") {
+            if (!request.rowId) {
+                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, request.rowId, rows)
+
+                } catch (e:any) {
+                    result.setError(500, "Unhandled exception in HTTP PUT doRequest: " + e.message, "DoRequest")
+                }             
+            }
+        } else if (request.method == "POST") {
+            if (request.rowId) {
+                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 {
+                    await this._doPost(result, rows, request)
+
+                } catch (e:any) {
+                    result.setError(500, "Unhandled exception in HTTP POST doRequest: " + e.message, "DoRequest")
+                }
+            }
+        } else if (request.method == "DELETE") {
+            if (!request.rowId)  {
+                result.setError(400, "HTTP DELETE method requires an id!", "DoRequest")
+
+            } else {
+                try {
+                    await this._doDelete(result, request.rowId, null)
+
+                } catch (e:any) {
+                    result.setError(500, "Unhandled exception in HTTP DELETE doRequest: " + e.message, "DoRequest")
+                }
+            }
+        } else {
+            result.setError(405, "Unsupported HTTP method '" + request.method + "' for REST request", "DoRequest")
+        }
+
+        OINOBenchmark.endMetric("OINODbApi", "doRequest." + request.method, result.status != 500)
+
+        return Promise.resolve(result)
+    }
+
+    /**
+     * Method for handling a HTTP REST request with batch update using PUT or DELETE methods.
+     * 
+     * @param method HTTP method of the REST request
+     * @param rowId URL id of the REST request
+     * @param rowData HTTP body data as either serialized string or unserialized JS object or OINODataRow-array or Buffer/Uint8Array binary data
+     *
+     */
+    async doBatchUpdate(method:string, rowId:string, rowData:OINOApiData, queryParams?: OINOQueryParams):Promise<OINOApiResult> {
+        return this.doApiRequest(new OINOApiRequest({ method: method, rowId: rowId, rowData: rowData, queryParams: queryParams }))
+    }
+    /**
+     * Method for handling a HTTP REST request with batch update using PUT or DELETE methods.
+     * 
+     * @param request HTTP URL parameters as key-value-pairs
+     *
+     */
+    async doBatchApiRequest(request:OINOApiRequest):Promise<OINOApiResult> {
+        OINOLog.debug("@oino-ts/db", "OINODbApi", "doBatchUpdate", "Request", {request:request, data:request.rowData})
+        let result:OINOApiResult = new OINOApiResult(request)
+        if ((request.method != "PUT") && (request.method != "DELETE")) {
+            result.setError(500, "Batch update only supports PUT and DELETE methods!", "DoBatchUpdate")
+            return Promise.resolve(result)
+        }
+        OINOBenchmark.startMetric("OINODbApi", "doBatchUpdate." + request.method)
+        const rows:OINODataRow[] = [] = this._parseData(result, request)
+        if (request.method == "PUT") {
+
+            try {
+                await this._doPut(result, null, rows)
+
+            } catch (e:any) {
+                result.setError(500, "Unhandled exception in HTTP PUT doRequest: " + e.message, "DoBatchUpdate")
+            }             
+
+        } else if (request.method == "DELETE") {
+            try {
+                await this._doDelete(result, null, rows)
+
+            } catch (e:any) {
+                result.setError(500, "Unhandled exception in HTTP DELETE doRequest: " + e.message, "DoBatchUpdate")
+            }
+        }
+        OINOBenchmark.endMetric("OINODbApi", "doBatchUpdate." + request.method, result.status != 500)
+        return Promise.resolve(result)
+    }
+
+    /**
+     * Method to check if a field is included in the API params.
+     *
+     * @param fieldName name of the field
+     * 
+     */
+
+    public isFieldIncluded(fieldName:string):boolean {
+        const params = this.params
+        return (
+            ((params.excludeFieldPrefix == undefined) || (params.excludeFieldPrefix == "") || (fieldName.startsWith(params.excludeFieldPrefix) == false)) && 
+            ((params.excludeFields == undefined) || (params.excludeFields.length == 0) || (params.excludeFields.indexOf(fieldName) < 0)) &&
+            ((params.includeFields == undefined) || (params.includeFields.length == 0) || (params.includeFields.indexOf(fieldName) >= 0))
+        ) 
+    }
+
 }