@oino-ts/db 0.16.2 → 0.17.1

package/dist/esm/OINODbApi.js

@@ -3,10 +3,65 @@
  * 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 { OINODbDataModel, OINOStringDataField, OINO_ERROR_PREFIX, OINODbModelSet, OINOBenchmark, OINODbConfig, OINOHtmlTemplate, OINONumberDataField, OINODbParser, OINODatetimeDataField } from "./index.js";
-import { OINOLog, OINOResult } from "@oino-ts/common";
+import { OINODbDataModel, OINOStringDataField, OINO_ERROR_PREFIX, OINODbModelSet, OINOBenchmark, OINODbConfig, OINOHtmlTemplate, OINONumberDataField, OINODbParser, OINODatetimeDataField, OINODbSqlAggregate, OINODbSqlSelect, OINODbSqlFilter, OINODbSqlOrder, OINODbSqlLimit } from "./index.js";
+import { OINOLog, OINOResult, OINOHttpRequest } from "@oino-ts/common";
 import { OINOHashid } from "@oino-ts/hashid";
-const API_EMPTY_PARAMS = { sqlParams: {} };
+export class OINODbApiRequest extends OINOHttpRequest {
+    rowId;
+    data;
+    sqlParams;
+    constructor(init) {
+        super(init);
+        this.rowId = init?.rowId || "";
+        this.data = init?.data || null;
+        this.sqlParams = init?.sqlParams || {};
+        if (init?.filter) {
+            this.sqlParams.filter = init.filter;
+        }
+        if (!this.sqlParams.filter) {
+            const filter_param = this.url?.searchParams.get(OINODbConfig.OINODB_SQL_FILTER_PARAM);
+            if (filter_param) {
+                this.sqlParams.filter = OINODbSqlFilter.parse(filter_param);
+            }
+        }
+        if (init?.order) {
+            this.sqlParams.order = 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) {
+            this.sqlParams.limit = 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) {
+            this.sqlParams.aggregate = 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) {
+            this.sqlParams.select = 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);
+            }
+        }
+    }
+}
 /**
  * OINO API request result object with returned data and/or http status code/message and
  * error / warning messages.
@@ -14,19 +69,19 @@ const API_EMPTY_PARAMS = { sqlParams: {} };
  */
 export class OINODbApiResult extends OINOResult {
     /** DbApi request params */
-    params;
+    request;
     /** Returned data if any */
     data;
     /**
      * Constructor of OINODbApiResult.
      *
-     * @param params DbApi request parameters
+     * @param request DbApi request parameters
      * @param data result data
      *
      */
-    constructor(params, data) {
+    constructor(request, data) {
         super();
-        this.params = params;
+        this.request = request;
         this.data = data;
     }
     /**
@@ -38,11 +93,11 @@ export class OINODbApiResult extends OINOResult {
     async writeApiResponse(headers = {}) {
         let response = null;
         if (this.success && this.data) {
-            const body = await this.data.writeString(this.params.responseType);
-            response = new Response(body, { status: this.statusCode, statusText: this.statusMessage, headers: headers });
+            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.statusCode, statusText: this.statusMessage, headers: headers });
+            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]);
@@ -215,14 +270,14 @@ export class OINODbApi {
         }
         //logDebug("OINODbApi.validateHttpValues", {result:result})
     }
-    _parseData(httpResult, body, params) {
+    _parseData(httpResult, request) {
         let rows = [];
         try {
-            if (Array.isArray(body)) {
-                rows = body;
+            if (Array.isArray(request.data)) {
+                rows = request.data;
             }
-            else {
-                rows = OINODbParser.createRows(this.datamodel, body, params);
+            else if (request.data != null) {
+                rows = OINODbParser.createRows(this.datamodel, request.data, request);
             }
         }
         catch (e) {
@@ -230,10 +285,10 @@ export class OINODbApi {
         }
         return rows;
     }
-    async _doGet(result, id, params) {
+    async _doGet(result, rowId, request) {
         let sql = "";
         try {
-            sql = this.datamodel.printSqlSelect(id, params.sqlParams || {});
+            sql = this.datamodel.printSqlSelect(rowId, request.sqlParams || {});
             OINOLog.debug("@oino-ts/db", "OINODbApi", "_doGet", "Print SQL", { sql: sql });
             const sql_res = await this.db.sqlSelect(sql);
             if (sql_res.hasErrors()) {
@@ -243,7 +298,7 @@ export class OINODbApi {
                 }
             }
             else {
-                result.data = new OINODbModelSet(this.datamodel, sql_res, params.sqlParams);
+                result.data = new OINODbModelSet(this.datamodel, sql_res, request.sqlParams);
             }
         }
         catch (e) {
@@ -375,28 +430,38 @@ export class OINODbApi {
         this._debugOnError = debugOnError;
     }
     /**
-     * Method for handlind a HTTP REST request with GET, POST, PUT, DELETE corresponding to
+     * Method for handling 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 data HTTP body data as either serialized string or unserialized JS object / OINODataRow-array
-     * @param params HTTP URL parameters as key-value-pairs
+     * @param method HTTP method of the REST request
+     * @param rowId URL id of the REST request
+     * @param data 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 doRequest(method, id, data, params = API_EMPTY_PARAMS) {
-        OINOBenchmark.startMetric("OINODbApi", "doRequest." + method);
-        OINOLog.debug("@oino-ts/db", "OINODbApi", "doRequest", "Request", { method: method, id: id, data: data });
-        let result = new OINODbApiResult(params);
+    async doRequest(method, rowId, data, sqlParams) {
+        return this.runRequest(new OINODbApiRequest({ method: method, rowId: rowId, data: data, sqlParams: sqlParams }));
+    }
+    /**
+     * Method for handling a HTTP REST request with GET, POST, PUT, DELETE corresponding to
+     * SQL select, insert, update and delete.
+     *
+     * @param request OINO DB API request
+     *
+     */
+    async runRequest(request) {
+        OINOBenchmark.startMetric("OINODbApi", "doRequest." + request.method);
+        OINOLog.debug("@oino-ts/db", "OINODbApi", "doRequest", "Request", { method: request.method, id: request.rowId, data: request.data });
+        let result = new OINODbApiResult(request);
         let rows = [];
-        if ((method == "POST") || (method == "PUT")) {
-            rows = this._parseData(result, data, params);
+        if ((request.method == "POST") || (request.method == "PUT")) {
+            rows = this._parseData(result, request);
         }
-        if (method == "GET") {
-            await this._doGet(result, id, params);
+        if (request.method == "GET") {
+            await this._doGet(result, request.rowId, request);
         }
-        else if (method == "PUT") {
-            if (!id) {
+        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) {
@@ -404,15 +469,15 @@ export class OINODbApi {
             }
             else {
                 try {
-                    await this._doPut(result, id, rows);
+                    await this._doPut(result, request.rowId, rows);
                 }
                 catch (e) {
                     result.setError(500, "Unhandled exception in HTTP PUT doRequest: " + e.message, "DoRequest");
                 }
             }
         }
-        else if (method == "POST") {
-            if (id) {
+        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) {
@@ -427,13 +492,13 @@ export class OINODbApi {
                 }
             }
         }
-        else if (method == "DELETE") {
-            if (!id) {
+        else if (request.method == "DELETE") {
+            if (!request.rowId) {
                 result.setError(400, "HTTP DELETE method requires an id!", "DoRequest");
             }
             else {
                 try {
-                    await this._doDelete(result, id, null);
+                    await this._doDelete(result, request.rowId, null);
                 }
                 catch (e) {
                     result.setError(500, "Unhandled exception in HTTP DELETE doRequest: " + e.message, "DoRequest");
@@ -441,29 +506,38 @@ export class OINODbApi {
             }
         }
         else {
-            result.setError(405, "Unsupported HTTP method '" + method + "' for REST request", "DoRequest");
+            result.setError(405, "Unsupported HTTP method '" + request.method + "' for REST request", "DoRequest");
         }
-        OINOBenchmark.endMetric("OINODbApi", "doRequest." + method);
+        OINOBenchmark.endMetric("OINODbApi", "doRequest." + request.method);
         return Promise.resolve(result);
     }
     /**
-     * Method for handlind a HTTP REST request with GET, POST, PUT, DELETE corresponding to
-     * SQL select, insert, update and delete.
+     * Method for handling a HTTP REST request with batch update using PUT or DELETE methods.
      *
-     * @param method HTTP verb (uppercase)
-     * @param data HTTP body data as either serialized string or unserialized JS object / OINODataRow-array
-     * @param params HTTP URL parameters as key-value-pairs
+     * @param method HTTP method of the REST request
+     * @param rowId URL id of the REST request
+     * @param data HTTP body data as either serialized string or unserialized JS object or OINODataRow-array or Buffer/Uint8Array binary data
      *
      */
-    async doBatchUpdate(method, data, params = API_EMPTY_PARAMS) {
-        OINOBenchmark.startMetric("OINODbApi", "doBatchUpdate." + method);
-        OINOLog.debug("@oino-ts/db", "OINODbApi", "doBatchUpdate", "Request", { method: method, data: data, params: params });
-        let result = new OINODbApiResult(params);
-        let rows = [];
-        if ((method == "PUT")) {
-            rows = this._parseData(result, data, params);
-        }
-        if (method == "PUT") {
+    async doBatchUpdate(method, rowId, data, sqlParams) {
+        return this.runRequest(new OINODbApiRequest({ method: method, rowId: rowId, data: data, 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) {
+        OINOLog.debug("@oino-ts/db", "OINODbApi", "doBatchUpdate", "Request", { request: request, data: request.data });
+        let result = 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 = [] = this._parseData(result, request);
+        if (request.method == "PUT") {
             try {
                 await this._doPut(result, null, rows);
             }
@@ -471,7 +545,7 @@ export class OINODbApi {
                 result.setError(500, "Unhandled exception in HTTP PUT doRequest: " + e.message, "DoBatchUpdate");
             }
         }
-        else if (method == "DELETE") {
+        else if (request.method == "DELETE") {
             try {
                 await this._doDelete(result, null, rows);
             }
@@ -479,10 +553,7 @@ export class OINODbApi {
                 result.setError(500, "Unhandled exception in HTTP DELETE doRequest: " + e.message, "DoBatchUpdate");
             }
         }
-        else {
-            result.setError(405, "Unsupported HTTP method '" + method + "' for batch update", "DoBatchUpdate");
-        }
-        OINOBenchmark.endMetric("OINODbApi", "doBatchUpdate." + method);
+        OINOBenchmark.endMetric("OINODbApi", "doBatchUpdate." + request.method);
         return Promise.resolve(result);
     }
     /**

package/dist/esm/OINODbConfig.js

@@ -15,10 +15,6 @@ export class OINODbConfig {
     static OINODB_SQL_AGGREGATE_PARAM = "oinosqlaggregate";
     /** Name of the OINODbSqlSelect-parameter in request */
     static OINODB_SQL_SELECT_PARAM = "oinosqlselect";
-    /** Name of the OINOContentType-parameter request */
-    static OINODB_REQUEST_TYPE = "oinorequesttype";
-    /** Name of the OINOContentType-parameter request */
-    static OINODB_RESPONSE_TYPE = "oinoresponsetype";
     /**
      * Set the name of the OINO ID field
      * @param idField name of the OINO ID field

package/dist/esm/OINODbFactory.js

@@ -3,7 +3,7 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at https://mozilla.org/MPL/2.0/.
  */
-import { OINODbApi, OINOContentType, OINODbSqlFilter, OINODbConfig, OINODbSqlOrder, OINODbSqlLimit, OINODbSqlAggregate, OINODbSqlSelect, OINOLog } from "./index.js";
+import { OINODbApi } from "./index.js";
 /**
  * Static factory class for easily creating things based on data
  *
@@ -39,13 +39,13 @@ export class OINODbFactory {
         if (connect) {
             const connect_res = await result.connect();
             if (connect_res.success == false) {
-                throw new Error("Database connection failed: " + connect_res.statusMessage);
+                throw new Error("Database connection failed: " + connect_res.statusText);
             }
         }
         if (validate) {
             const validate_res = await result.validate();
             if (validate_res.success == false) {
-                throw new Error("Database validation failed: " + validate_res.statusMessage);
+                throw new Error("Database validation failed: " + validate_res.statusText);
             }
         }
         return result;
@@ -61,69 +61,4 @@ export class OINODbFactory {
         await db.initializeApiDatamodel(result);
         return result;
     }
-    /**
-     * Creates a key-value-collection from Javascript URL parameters.
-     *
-     * @param request HTTP Request
-     */
-    static createParamsFromRequest(request) {
-        const url = new URL(request.url);
-        let sql_params = {};
-        const filter = url.searchParams.get(OINODbConfig.OINODB_SQL_FILTER_PARAM);
-        if (filter) {
-            sql_params.filter = OINODbSqlFilter.parse(filter);
-        }
-        const order = url.searchParams.get(OINODbConfig.OINODB_SQL_ORDER_PARAM);
-        if (order) {
-            sql_params.order = OINODbSqlOrder.parse(order);
-        }
-        const limit = url.searchParams.get(OINODbConfig.OINODB_SQL_LIMIT_PARAM);
-        if (limit) {
-            sql_params.limit = OINODbSqlLimit.parse(limit);
-        }
-        const aggregate = url.searchParams.get(OINODbConfig.OINODB_SQL_AGGREGATE_PARAM);
-        if (aggregate) {
-            sql_params.aggregate = OINODbSqlAggregate.parse(aggregate);
-        }
-        const select = url.searchParams.get(OINODbConfig.OINODB_SQL_SELECT_PARAM);
-        if (select) {
-            sql_params.select = OINODbSqlSelect.parse(select);
-        }
-        let result = { sqlParams: sql_params };
-        const request_type = url.searchParams.get(OINODbConfig.OINODB_REQUEST_TYPE) || request.headers.get("content-type"); // content-type header can be overridden by query parameter
-        if (request_type == OINOContentType.csv) {
-            result.requestType = OINOContentType.csv;
-        }
-        else if (request_type == OINOContentType.urlencode) {
-            result.requestType = OINOContentType.urlencode;
-        }
-        else if (request_type?.startsWith(OINOContentType.formdata)) {
-            result.requestType = OINOContentType.formdata;
-            result.multipartBoundary = request_type.split('boundary=')[1] || "";
-        }
-        else {
-            result.requestType = OINOContentType.json;
-        }
-        const response_type = url.searchParams.get(OINODbConfig.OINODB_RESPONSE_TYPE) || request.headers.get("accept"); // accept header can be overridden by query parameter
-        const accept_types = response_type?.split(', ') || [];
-        for (let i = 0; i < accept_types.length; i++) {
-            if (Object.values(OINOContentType).includes(accept_types[i])) {
-                result.responseType = accept_types[i];
-                break;
-            }
-        }
-        if (result.responseType === undefined) {
-            result.responseType = OINOContentType.json;
-        }
-        const last_modified = request.headers.get("if-modified-since");
-        if (last_modified) {
-            result.lastModified = new Date(last_modified).getTime();
-        }
-        const etags = request.headers.get("if-none-match")?.split(',').map(e => e.trim());
-        if (etags) {
-            result.etags = etags;
-        }
-        OINOLog.debug("@oino-ts/db", "OINODbFactory", "createParamsFromRequest", "Result", { params: result });
-        return result;
-    }
 }

package/dist/esm/OINODbParser.js

@@ -13,20 +13,20 @@ export class OINODbParser {
      * Create data rows from request body based on the datamodel.
      *
      * @param datamodel datamodel of the api
-     * @param data data as a string or Buffer or object
-     * @param requestParams parameters
+     * @param data data as either serialized string or unserialized JS object or OINODataRow-array or Buffer/Uint8Array binary data
+     * @param request parameters
      *
      */
-    static createRows(datamodel, data, requestParams) {
+    static createRows(datamodel, data, request) {
         let result = [];
         if (typeof data == "string") {
-            result = this.createRowsFromText(datamodel, data, requestParams);
+            result = this._createRowsFromText(datamodel, data, request);
         }
-        else if (data instanceof Buffer) {
-            result = this.createRowsFromBlob(datamodel, data, requestParams);
+        else if ((data instanceof Buffer) || (data instanceof Uint8Array)) {
+            result = this._createRowsFromBlob(datamodel, data, request);
         }
         else if (typeof data == "object") {
-            result = [this.createRowFromObject(datamodel, data)];
+            result = [this._createRowFromObject(datamodel, data)];
         }
         return result;
     }
@@ -35,28 +35,28 @@ export class OINODbParser {
       *
       * @param datamodel datamodel of the api
       * @param data data as a string
-      * @param requestParams parameters
+      * @param request request parameters
       *
       */
-    static createRowsFromText(datamodel, data, requestParams) {
-        if ((requestParams.requestType == OINOContentType.json) || (requestParams.requestType == undefined)) {
+    static _createRowsFromText(datamodel, data, request) {
+        if ((request.requestType == OINOContentType.json) || (request.requestType == undefined)) {
             return this._createRowFromJson(datamodel, data);
         }
-        else if (requestParams.requestType == OINOContentType.csv) {
+        else if (request.requestType == OINOContentType.csv) {
             return this._createRowFromCsv(datamodel, data);
         }
-        else if (requestParams.requestType == OINOContentType.formdata) {
-            return this._createRowFromFormdata(datamodel, Buffer.from(data, "utf8"), requestParams.multipartBoundary || "");
+        else if (request.requestType == OINOContentType.formdata) {
+            return this._createRowFromFormdata(datamodel, Buffer.from(data, "utf8"), request.multipartBoundary || "");
         }
-        else if (requestParams.requestType == OINOContentType.urlencode) {
+        else if (request.requestType == OINOContentType.urlencode) {
             return this._createRowFromUrlencoded(datamodel, data);
         }
-        else if (requestParams.requestType == OINOContentType.html) {
+        else if (request.requestType == OINOContentType.html) {
             OINOLog.error("@oino-ts/db", "OINODbParser", "createRowsFromText", "HTML can't be used as an input content type!", { contentType: OINOContentType.html });
             return [];
         }
         else {
-            OINOLog.error("@oino-ts/db", "OINODbParser", "createRowsFromText", "Unrecognized input content type!", { contentType: requestParams.requestType });
+            OINOLog.error("@oino-ts/db", "OINODbParser", "createRowsFromText", "Unrecognized input content type!", { contentType: request.requestType });
             return [];
         }
     }
@@ -64,29 +64,32 @@ export class OINODbParser {
       * Create data rows from request body based on the datamodel.
       *
       * @param datamodel datamodel of the api
-      * @param data data as an Buffer
-      * @param requestParams parameters
+      * @param data data as an Buffer or Uint8Array
+      * @param request parameters
       *
       */
-    static createRowsFromBlob(datamodel, data, requestParams) {
-        if ((requestParams.requestType == OINOContentType.json) || (requestParams.requestType == undefined)) {
+    static _createRowsFromBlob(datamodel, data, request) {
+        if (data instanceof Uint8Array && !(data instanceof Buffer)) {
+            data = Buffer.from(data);
+        }
+        if ((request.requestType == OINOContentType.json) || (request.requestType == undefined)) {
             return this._createRowFromJson(datamodel, data.toString()); // JSON is always a string
         }
-        else if (requestParams.requestType == OINOContentType.csv) {
+        else if (request.requestType == OINOContentType.csv) {
             return this._createRowFromCsv(datamodel, data.toString()); // binary data has to be base64 encoded so it's a string
         }
-        else if (requestParams.requestType == OINOContentType.formdata) {
-            return this._createRowFromFormdata(datamodel, data, requestParams.multipartBoundary || "");
+        else if (request.requestType == OINOContentType.formdata) {
+            return this._createRowFromFormdata(datamodel, data, request.multipartBoundary || "");
         }
-        else if (requestParams.requestType == OINOContentType.urlencode) {
+        else if (request.requestType == OINOContentType.urlencode) {
             return this._createRowFromUrlencoded(datamodel, data.toString()); // data is urlencoded so it's a string
         }
-        else if (requestParams.requestType == OINOContentType.html) {
+        else if (request.requestType == OINOContentType.html) {
             OINOLog.error("@oino-ts/db", "OINODbParser", "createRowsFromBlob", "HTML can't be used as an input content type!", { contentType: OINOContentType.html });
             return [];
         }
         else {
-            OINOLog.error("@oino-ts/db", "OINODbParser", "createRowsFromBlob", "Unrecognized input content type!", { contentType: requestParams.requestType });
+            OINOLog.error("@oino-ts/db", "OINODbParser", "createRowsFromBlob", "Unrecognized input content type!", { contentType: request.requestType });
             return [];
         }
     }
@@ -98,7 +101,7 @@ export class OINODbParser {
      * @param data data as javascript object
      *
      */
-    static createRowFromObject(datamodel, data) {
+    static _createRowFromObject(datamodel, data) {
         const fields = datamodel.fields;
         let result = new Array(fields.length);
         for (let i = 0; i < fields.length; i++) {

package/dist/esm/OINODbSwagger.js

@@ -53,10 +53,10 @@ export class OINODbSwagger {
                 "success": {
                     "type": "boolean"
                 },
-                "statusCode": {
+                "status": {
                     "type": "number"
                 },
-                "statusMessage": {
+                "statusText": {
                     "type": "string"
                 },
                 "messages": {
@@ -68,8 +68,8 @@ export class OINODbSwagger {
             },
             "required": [
                 "success",
-                "statusCode",
-                "statusMessage",
+                "status",
+                "statusText",
                 "messages"
             ]
         };

package/dist/esm/index.js

@@ -1,7 +1,7 @@
 import { OINOContentType } from "@oino-ts/common";
 export { OINOContentType };
 export { OINO_ERROR_PREFIX, OINO_WARNING_PREFIX, OINO_INFO_PREFIX, OINO_DEBUG_PREFIX, OINOStr, OINOBenchmark, OINOMemoryBenchmark, OINOLog, OINOLogLevel, OINOConsoleLog, OINOResult, OINOHttpResult, OINOHtmlTemplate } from "@oino-ts/common";
-export { OINODbApiResult, OINODbHtmlTemplate, OINODbApi } from "./OINODbApi.js";
+export { OINODbApiResult, OINODbHtmlTemplate, OINODbApi, OINODbApiRequest } from "./OINODbApi.js";
 export { OINODbDataModel } from "./OINODbDataModel.js";
 export { OINODbModelSet } from "./OINODbModelSet.js";
 export { OINODbDataField, OINOBooleanDataField, OINONumberDataField, OINOStringDataField, OINOBlobDataField, OINODatetimeDataField } from "./OINODbDataField.js";

package/dist/types/OINODb.d.ts

@@ -8,8 +8,8 @@ export declare abstract class OINODb {
     protected _params: OINODbParams;
     /** Name of the database */
     readonly name: string;
-    protected isConnected: boolean;
-    protected isValidated: boolean;
+    isConnected: boolean;
+    isValidated: boolean;
     /**
      * Constructor for `OINODb`.
      * @param params database parameters