@oino-ts/db-postgresql 0.0.11

package/README.md

@@ -0,0 +1,222 @@
+# OINO TS
+ OINO Is Not an ORM but it's trying to solve a similar problem for API development. Instead of mirroring your DB schema in code that needs manual updates, OINO will get the data schema from DBMS using SQL in real time. Every time your app starts, it has an updated data model which enables automatic (de)serialize SQL results to JSON/CSV and back. OINO works on the level below routing where you pass the method, URL ID, body and request parameters to the API-object. OINO will parse and validate the data against the data model and generate proper SQL for your DB. Because OINO knows how data is serialized (e.g. JSON), what column it belongs to (e.g. floating point number) and what the target database is, it knows how to parse, format and escape the value as valid SQL.
+ 
+ ```
+ const result:OINOApiResult = await api_orderdetails.doRequest("GET", id, body, params)
+ return new Response(result.modelset.writeString(OINOContentType.json))
+ ```
+ 
+
+ # GETTING STARTED
+ 
+ ### Setup
+ Install the `@oino-ts/core` npm package and necessary database packages and import them in your code.
+ ```
+ bun install @oino-ts/core
+ bun install @oino-ts/bunsqlite
+ ```
+ 
+ ```
+ import { OINODb, OINOApi, OINOFactory } from "@oino-ts/core";
+ import { OINODbBunSqlite } from "@oino-ts/bunsqlite"
+ ```
+ 
+ ### Register database and logger
+ Register your database implementation and logger (see [`OINOConsoleLog`](https://pragmatta.github.io/oino-ts/classes/core_src.OINOConsoleLog.html) how to implement your own)
+
+ ```
+ OINOLog.setLogger(new OINOConsoleLog())
+ OINOFactory.registerDb("OINODbBunSqlite", OINODbBunSqlite)
+ ```
+
+ ### Create a database
+ Creating a database connection [`OINODb`](https://pragmatta.github.io/oino-ts/classes/core_src_OINODb.OINODb.html) is done by passing [`OINODbParams`](https://pragmatta.github.io/oino-ts/types/core_src.OINODbParams.html) to the factory method. For [`OINODbBunSqlite`](https://pragmatta.github.io/oino-ts/classes/bunsqlite_OINODbBunSqlite.OINODbBunSqlite.html) that means a file url for the database file, for others network host, port, credentials etc.
+ ```
+ const db:OINODb = await OINOFactory.createDb( { type: "OINODbBunSqlite", url: "file://../localDb/northwind.sqlite" } )
+ ```
+
+ ### Create an API
+ From a database you can create an [`OINOApi`](https://pragmatta.github.io/oino-ts/classes/core_src_OINOApi.OINOApi.html) by passing [`OINOApiParams`](https://pragmatta.github.io/oino-ts/types/core_src.OINOApiParams.html) with table name and preferences to the factory method.
+ ```
+ const api_employees:OINOApi = await OINOFactory.createApi(db, { tableName: "Employees", excludeFields:["BirthDate"] })
+ ```
+
+ ### Pass HTTP requests to API
+ When you receive a HTTP request, just pass the method, URL ID, body and params to the correct API, which will parse and validate input and return results.
+
+ ```
+ const result:OINOApiResult = await api_orderdetails.doRequest("GET", id, body, params)
+ ```
+
+ ### Write results back to HTTP Response
+ The results for a GET request will contain [`OINOModelSet`](https://pragmatta.github.io/oino-ts/classes/core_src_OINOModelSet.OINOModelSet.html) data that can be written out as JSON or CSV as needed. For other requests result is just success or error with messages.
+ ```
+ return new Response(result.modelset.writeString(OINOContentType.json))
+ ```
+ 
+ 
+ # FEATURES
+ 
+ ## RESTfull
+ OINO maps HTTP methods GET/POST/PUT/DELETE to SQL operations SELECT/INSERT/UPDATE/DELETE. The GET/POST requests can be made without URL ID to get all rows or insert new ones and others target a single row using URL ID. 
+ 
+ ### HTTP GET
+ ```
+ Request and response:
+ > curl.exe -X GET http://localhost:3001/orderdetails/11077:77
+ [
+   {"_OINOID_":"11077:77","OrderID":11077,"ProductID":77,"UnitPrice":13,"Quantity":2,"Discount":0}
+ ]
+
+ SQL:
+ SELECT "OrderID","ProductID","UnitPrice","Quantity","Discount" FROM [OrderDetails] WHERE ("OrderID"=11077 AND "ProductID"=77);
+ ```
+
+ ### HTTP POST 
+ ```
+ Request and response:
+ > curl.exe -X POST http://localhost:3001/orderdetails -H "Content-Type: application/json" --data '[{\"OrderID\":11077,\"ProductID\":99,\"UnitPrice\":19,\"Quantity\":1,\"Discount\":0}]'
+ {"success":true,"statusCode":200,"statusMessage":"OK","messages":[]}
+
+ SQL:
+ INSERT INTO [OrderDetails] ("OrderID","ProductID","UnitPrice","Quantity","Discount") VALUES (11077,99,19,1,0);
+ ```
+
+ ### HTTP PUT
+ ```
+ Request and response:
+ > curl.exe -X PUT http://localhost:3001/orderdetails/11077:99 -H "Content-Type: application/json" --data '[{\"UnitPrice\":20}]'
+ {"success":true,"statusCode":200,"statusMessage":"OK","messages":[]}
+
+ SQL:
+ UPDATE [OrderDetails] SET "UnitPrice"=20 WHERE ("OrderID"=11077 AND "ProductID"=99);
+ ```
+ 
+ ### HTTP DELETE
+ ```
+ Request and response:
+ > curl.exe -X DELETE http://localhost:3001/orderdetails/11077:99
+ {"success":true,"statusCode":200,"statusMessage":"OK","messages":[]}
+
+ SQL:
+ DELETE FROM [OrderDetails] WHERE ("OrderID"=11077 AND "ProductID"=99);
+ ```
+  
+ ## Universal Serialization
+ OINO handles serialization of data to JSON/CSV/etc. and back based on the data model. It knows what columns exist, what is their data type and how to convert each to JSON/CSV and back. This allows also partial data to be sent, i.e. you can send only columns that need updating or even send extra columns and have them ignored.
+
+ ### Features
+ - Files can be sent to BLOB fields using BASE64 encoding.
+ - Datetimes are (optionally) normalized to ISO 8601 format.
+ - Extended JSON-encoding
+   - Unquoted literal `undefined` can be used to represent non-existent values (leaving property out works too but preserving structure might be easier e.g. when translating data).
+ - CSV
+   - Comma-separated, doublequotes.
+   - Unquoted literal `null` represents null values.
+   - Unquoted empty string represents undefined values.
+ - Form data
+   - Multipart-mixed and binary files not supported.
+   - Non-existent value line (i.e. nothing after the empty line) treated as a null value.
+ - Url-encoded
+   - No null values, missing properties treated as undefined.
+   - Multiple lines could be used to post multiple rows.
+
+
+ ## Database Abstraction
+ OINO functions as a database abstraction, providing a consistent interface for working with different databases. It abstracts out different conventions in connecting, making queries and formatting data.
+
+ Currently supported databases:
+ - Bun Sqlite through Bun native implementation
+ - Postgresql through [pg](https://www.npmjs.com/package/pg)-package
+ - Mariadb / Mysql-support through [mariadb](https://www.npmjs.com/package/mariadb)-package
+
+ ## Complex Keys
+ To support tables with multipart primary keys OINO generates a composite key `_OINOID_` that is included in the result and can be used as the REST ID. For example in the example above table `OrderDetails` has two primary keys `OrderID` and `ProductID` making the `_OINOID_` of form `11077:99`. 
+
+ ## Power Of SQL
+ Since OINO controls the SQL, WHERE-conditions can be defined with [`OINOSqlFilter`](https://pragmatta.github.io/oino-ts/classes/core_src.OINOSqlFilter.html) and order with [`OINOSqlOrder`](https://pragmatta.github.io/oino-ts/classes/core_src.OINOSqlOrder.html) that are passed as HTTP request parameters. No more API development where you make unique API endpoints for each filter that fetch all data with original API and filter in backend code. Every API can be filtered when and as needed without unnessecary data tranfer and utilizing SQL indexing when available.
+
+ ## Swagger Support
+ Swagger is great as long as the definitions are updated and with OINO you can automatically get a Swagger definition including a data model schema.
+ ```
+ if (url.pathname == "/swagger.json") {
+    return new Response(JSON.stringify(OINOSwagger.getApiDefinition(api_array)))
+ }
+ ```
+ ![Swagger definition with a data model schema](img/readme-swagger.png)
+
+ ## Node support
+ OINO is developped Typescript first but compiles to standard CommonJS and the NPM packages should work on either ESM / CommonJS. Checkout sample apps `readmeApp` (ESM) and `nodeApp` (CommonJS).
+
+ ## HTMX support
+ OINO is [htmx.org](https://htmx.org) friendly, allowing easy translation of [`OINODataRow`](https://pragmatta.github.io/oino-ts/types/core_src.OINODataRow.html) to HTML output using templates (cf. the [htmx sample app](https://github.com/pragmatta/oino-ts/tree/main/samples/htmxApp)).
+
+ ### Hashids
+ Autoinc numeric id's are very pragmatic and fit well with OINO (e.g. using a form without primary key fields to insert new rows with database assigned ids). However it's not always sensible to share information about the sequence. Hashids solve this by masking the original values by encrypting the ids using AES-128 and some randomness. Length of the hashid can be chosen from 12-32 characters where longer ids provide more security. However this should not be considereded a cryptographic solution for keeping ids secret but rather making it infeasible to iterate all ids.
+
+
+ # STATUS
+ OINO is currently a hobby project which should and should considered in alpha status. That also means compatibility breaking changes can be made without prior notice when architectual issues are discovered.
+
+ ## Beta
+ For a beta status following milestones are planned:
+
+ ### Realistic app
+ There needs to be a realistic app built on top of OINO to get a better grasp of the edge cases.
+
+ ### Security review
+ Handling of SQL-injection attacks needs a thorough review, what are the relevant attack vectors are for OINO and what protections are still needed.
+ 
+ ## Roadmap
+ Things that need to happen in some order before beta-status are at least following:
+ 
+ ### Support for views
+ Simple cases of views would work already in some databases but edge cases might get complicated. For example 
+ - How to handle a view which does not have a complete private key?
+ - What edge cases exist in updating views?
+
+ ### Batch updates
+ Supporting batch updates similar to batch inserts is slightly bending the RESTfull principles but would still be a useful optional feature.
+
+ ### Aggregation and limits
+ Similar to filtering and ordering, aggregation and limits can be implemented as HTTP request parameters telling what column is aggregated or used for ordering or how many results to return.
+
+ ### Streaming
+ One core idea is to be efficient in not making unnecessary copies of the data and minimizing garbage collection debt. This can be taken further by implementing streaming, allowing large dataset to be written to HTTP response as SQL result rows are received.
+
+ ### SQL generation callbacks
+ It would be useful to allow developer to validate / override SQL generation to cover cases OINO does not support or even workaround issues.
+
+ ### Transactions
+ Even though the basic case for OINO is executing SQL operations on individual rows, having an option to use SQL transactions could make sense at least for batch operations.
+
+
+ # HELP
+ 
+ ## Bug reports
+ Fixing bugs is a priority and getting good quality bug reports helps. It's recommended to use the sample Northwind database included with project to replicate issues or make an SQL script export of the relevant table.
+  
+ ## Feedback
+ Understanding and prioritizing the use cases for OINO is also important and feedback about how you'd use OINO is interesting. Feel free to raise issues and feature requests in Github, but understand that short term most of the effort goes towards reaching the beta stage.
+
+ ## Typescript / Javascript architecture
+ Typescript building with different targets and module-systemts and a ton of configuration is a complex domain and something I have little experience un so help in fixing problems and how thing ought to be done is appreciated.
+ 
+ # LINKS
+ - [Github repository](https://github.com/pragmatta/oino-ts)
+ - [NPM repository](https://www.npmjs.com/org/oino-ts) 
+
+ 
+ # ACKNOWLEDGEMENTS
+ 
+ ## Libraries
+ OINO uses the following open source libraries and npm packages and I would like to thank everyone for their contributions:
+ - Postgresql support by [node-postgres package](https://www.npmjs.com/package/pg)
+ - Mariadb / Mysql-support by [mariadb package](https://www.npmjs.com/package/mariadb)
+
+ ## Bun
+ OINO has been developed using the Bun runtime, not because of the speed improvements but for the first class Typescript support and integrated developper experience. Kudos on the bun team for making Typescript work more exiting again.
+ 
+ ## SQL Scripts
+ The SQL scripts for creating the sample Northwind database are based on [Google Code archive](https://code.google.com/archive/p/northwindextended/downloads) and have been further customized to ensure they would have identical data (in the scope of the automated testing).
+

package/dist/cjs/OINODbPostgresql.js

@@ -0,0 +1,330 @@
+"use strict";
+/*
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OINODbPostgresql = void 0;
+const db_1 = require("@oino-ts/db");
+const pg_1 = require("pg");
+const EMPTY_ROW = [];
+/**
+ * Implmentation of OINODbDataSet for Postgresql.
+ *
+ */
+class OINOPostgresqlData extends db_1.OINODbDataSet {
+    _rows;
+    /**
+     * OINOPostgresqlData constructor
+     * @param params database parameters
+     */
+    constructor(data, messages = []) {
+        super(data, messages);
+        if ((data != null) && !(Array.isArray(data))) {
+            throw new Error(db_1.OINO_ERROR_PREFIX + ": Invalid Posgresql data type!"); // TODO: maybe check all rows
+        }
+        this._rows = data;
+        if (this.isEmpty()) {
+            this._currentRow = -1;
+            this._eof = true;
+        }
+        else {
+            this._currentRow = 0;
+            this._eof = false;
+        }
+    }
+    _currentRow;
+    _eof;
+    isEmpty() {
+        return (this._rows.length == 0);
+    }
+    // EOF means "there is no more content", i.e. either dataset is empty or we have moved beyond last line
+    isEof() {
+        return (this._eof);
+    }
+    next() {
+        // OINOLog.debug("OINODbDataSet.next", {currentRow:this._currentRow, length:this.sqlResult.data.length})
+        if (this._currentRow < this._rows.length - 1) {
+            this._currentRow = this._currentRow + 1;
+        }
+        else {
+            this._eof = true;
+        }
+        return !this._eof;
+    }
+    getRow() {
+        if ((this._currentRow >= 0) && (this._currentRow < this._rows.length)) {
+            return this._rows[this._currentRow];
+        }
+        else {
+            return EMPTY_ROW;
+        }
+    }
+}
+/**
+ * Implementation of Postgresql-database.
+ *
+ */
+class OINODbPostgresql extends db_1.OINODb {
+    static table_schema_sql = `SELECT 
+    col.column_name, 
+    col.data_type, 
+    col.character_maximum_length, 
+    col.is_nullable, 
+    pk.primary_key,
+    col.numeric_precision,
+    col.numeric_scale,
+    col.column_default
+FROM information_schema.columns col
+LEFT JOIN LATERAL
+	(select kcu.column_name, 'YES' as primary_key
+	from 
+		information_schema.table_constraints tco,
+		information_schema.key_column_usage kcu 	 
+	where 
+		kcu.constraint_name = tco.constraint_name
+		and kcu.constraint_schema = tco.constraint_schema
+		and tco.table_name = col.table_name
+		and tco.constraint_type = 'PRIMARY KEY'
+	) pk on col.column_name = pk.column_name
+WHERE table_name = `;
+    // private _client:Client
+    _pool;
+    /**
+     * Constructor of `OINODbPostgresql`
+     * @param params database paraneters
+     */
+    constructor(params) {
+        super(params);
+        // OINOLog.debug("OINODbPostgresql.constructor", {params:params})
+        if (this._params.type !== "OINODbPostgresql") {
+            throw new Error(db_1.OINO_ERROR_PREFIX + ": Not OINODbPostgresql-type: " + this._params.type);
+        }
+        this._pool = new pg_1.Pool({ host: params.url, database: params.database, port: params.port, user: params.user, password: params.password });
+        this._pool.on("error", (err) => {
+            db_1.OINOLog.error("OINODbPostgresql error", { err: err });
+        });
+        this._pool.on("connect", (message) => {
+            // OINOLog.info("OINODbPostgresql connect")
+        });
+        this._pool.on("release", (message) => {
+            // OINOLog.info("OINODbPostgresql notice")
+        });
+        this._pool.on("acquire", () => {
+            // OINOLog.info("OINODbPostgresql end")
+        });
+    }
+    _parseFieldLength(fieldLength) {
+        let result = parseInt((fieldLength || "0").toString());
+        if (Number.isNaN(result)) {
+            result = 0;
+        }
+        return result;
+    }
+    async _query(sql) {
+        // OINOLog.debug("OINODbPostgresql._query", {sql:sql})
+        const query_result = await this._pool.query({ rowMode: "array", text: sql });
+        // OINOLog.debug("OINODbPostgresql._query", {result:query_result})
+        return Promise.resolve(query_result.rows);
+    }
+    async _exec(sql) {
+        // OINOLog.debug("OINODbPostgresql._query", {sql:sql})
+        const query_result = await this._pool.query({ rowMode: "array", text: sql });
+        // OINOLog.debug("OINODbPostgresql._query", {result:query_result})
+        return Promise.resolve(query_result.rows);
+    }
+    /**
+     * Print a table name using database specific SQL escaping.
+     *
+     * @param sqlTable name of the table
+     *
+     */
+    printSqlTablename(sqlTable) {
+        return "\"" + sqlTable.toLowerCase() + "\"";
+    }
+    /**
+     * Print a column name with correct SQL escaping.
+     *
+     * @param sqlColumn name of the column
+     *
+     */
+    printSqlColumnname(sqlColumn) {
+        return "\"" + sqlColumn + "\"";
+    }
+    /**
+     * 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
+     *
+     */
+    printCellAsSqlValue(cellValue, sqlType) {
+        if (cellValue === null) {
+            return "NULL";
+        }
+        else if (cellValue === undefined) {
+            return "UNDEFINED";
+        }
+        else if ((sqlType == "integer") || (sqlType == "smallint") || (sqlType == "real")) {
+            return cellValue.toString();
+        }
+        else if (sqlType == "bytea") {
+            return "\'" + cellValue + "\'";
+        }
+        else if (sqlType == "boolean") {
+            if (cellValue == null || cellValue == "" || cellValue.toString().toLowerCase() == "false" || cellValue == "0") {
+                return "false";
+            }
+            else {
+                return "true";
+            }
+        }
+        else if ((sqlType == "date") && (cellValue instanceof Date)) {
+            return "\'" + cellValue.toISOString() + "\'";
+        }
+        else {
+            return "\'" + cellValue?.toString().replaceAll("'", "''") + "\'";
+        }
+    }
+    /**
+     * 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
+     *
+     */
+    parseSqlValueAsCell(sqlValue, sqlType) {
+        if ((sqlValue === null) || (sqlValue == "NULL")) {
+            return null;
+        }
+        else if ((sqlValue === undefined)) {
+            return undefined;
+        }
+        else if (((sqlType == "date")) && (typeof (sqlValue) == "string")) {
+            return new Date(sqlValue);
+        }
+        else {
+            return sqlValue;
+        }
+    }
+    /**
+     * Connect to database.
+     *
+     */
+    async connect() {
+        try {
+            // make sure that any items are correctly URL encoded in the connection string
+            // OINOLog.debug("OINODbPostgresql.connect")
+            // await this._pool.connect()
+            // await this._client.connect()
+            return Promise.resolve(true);
+        }
+        catch (err) {
+            // ... error checks
+            throw new Error(db_1.OINO_ERROR_PREFIX + ": Error connecting to Postgresql server: " + err);
+        }
+    }
+    /**
+     * Execute a select operation.
+     *
+     * @param sql SQL statement.
+     *
+     */
+    async sqlSelect(sql) {
+        db_1.OINOBenchmark.start("sqlSelect");
+        let result;
+        try {
+            const rows = await this._query(sql);
+            // OINOLog.debug("OINODbPostgresql.sqlSelect", {rows:rows})
+            result = new OINOPostgresqlData(rows, []);
+        }
+        catch (e) {
+            result = new OINOPostgresqlData([[]], [db_1.OINO_ERROR_PREFIX + " (sqlSelect): exception in _db.query [" + e.message + "]"]);
+        }
+        db_1.OINOBenchmark.end("sqlSelect");
+        return result;
+    }
+    /**
+     * Execute other sql operations.
+     *
+     * @param sql SQL statement.
+     *
+     */
+    async sqlExec(sql) {
+        db_1.OINOBenchmark.start("sqlExec");
+        let result;
+        try {
+            const rows = await this._exec(sql);
+            // OINOLog.debug("OINODbPostgresql.sqlExec", {rows:rows})
+            result = new OINOPostgresqlData(rows, []);
+        }
+        catch (e) {
+            result = new OINOPostgresqlData([[]], [db_1.OINO_ERROR_PREFIX + " (sqlExec): exception in _db.exec [" + e.message + "]"]);
+        }
+        db_1.OINOBenchmark.end("sqlExec");
+        return result;
+    }
+    /**
+     * Initialize a data model by getting the SQL schema and populating OINODbDataFields of
+     * the model.
+     *
+     * @param api api which data model to initialize.
+     *
+     */
+    async initializeApiDatamodel(api) {
+        const res = await this.sqlSelect(OINODbPostgresql.table_schema_sql + "'" + api.params.tableName.toLowerCase() + "';");
+        // OINOLog.debug("OINODbPostgresql.initializeApiDatamodel: table description ", {res: res })
+        while (!res.isEof()) {
+            const row = res.getRow();
+            // OINOLog.debug("OINODbPostgresql.initializeApiDatamodel: next row ", {row: row })
+            const field_name = row[0]?.toString() || "";
+            const sql_type = row[1]?.toString() || "";
+            const field_length = this._parseFieldLength(row[2]);
+            const numeric_precision = this._parseFieldLength(row[5]);
+            const numeric_scale = this._parseFieldLength(row[6]);
+            const default_val = row[7]?.toString() || "";
+            const field_params = {
+                isPrimaryKey: row[4] == "YES",
+                isNotNull: row[3] == "NO",
+                isAutoInc: default_val.startsWith("nextval(")
+            };
+            if ((!api.params.excludeFieldPrefix || !field_name.startsWith(api.params.excludeFieldPrefix)) && (!api.params.excludeFields || (api.params.excludeFields.indexOf(field_name) < 0))) {
+                // OINOLog.debug("OINODbPostgresql.initializeApiDatamodel: next field ", {field_name: field_name, sql_type:sql_type, field_length:field_length, field_params:field_params })
+                if ((sql_type == "integer") || (sql_type == "smallint") || (sql_type == "real")) {
+                    api.datamodel.addField(new db_1.OINONumberDataField(this, field_name, sql_type, field_params));
+                }
+                else if ((sql_type == "date")) {
+                    if (api.params.useDatesAsString) {
+                        api.datamodel.addField(new db_1.OINOStringDataField(this, field_name, sql_type, field_params, 0));
+                    }
+                    else {
+                        api.datamodel.addField(new db_1.OINODatetimeDataField(this, field_name, sql_type, field_params));
+                    }
+                }
+                else if ((sql_type == "character") || (sql_type == "character varying") || (sql_type == "varchar") || (sql_type == "text")) {
+                    api.datamodel.addField(new db_1.OINOStringDataField(this, field_name, sql_type, field_params, field_length));
+                }
+                else if ((sql_type == "bytea")) {
+                    api.datamodel.addField(new db_1.OINOBlobDataField(this, field_name, sql_type, field_params, field_length));
+                }
+                else if ((sql_type == "boolean")) {
+                    api.datamodel.addField(new db_1.OINOBooleanDataField(this, field_name, sql_type, field_params));
+                }
+                else if ((sql_type == "decimal") || (sql_type == "numeric")) {
+                    api.datamodel.addField(new db_1.OINOStringDataField(this, field_name, sql_type, field_params, numeric_precision + numeric_scale + 1));
+                }
+                else {
+                    db_1.OINOLog.info("OINODbPostgresql.initializeApiDatamodel: unrecognized field type treated as string", { field_name: field_name, sql_type: sql_type, field_length: field_length, field_params: field_params });
+                    api.datamodel.addField(new db_1.OINOStringDataField(this, field_name, sql_type, field_params, 0));
+                }
+            }
+            res.next();
+        }
+        db_1.OINOLog.debug("OINODbPostgresql.initializeDatasetModel:\n" + api.datamodel.printDebug("\n"));
+        return Promise.resolve();
+    }
+}
+exports.OINODbPostgresql = OINODbPostgresql;

package/dist/cjs/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OINODbPostgresql = void 0;
+var OINODbPostgresql_js_1 = require("./OINODbPostgresql.js");
+Object.defineProperty(exports, "OINODbPostgresql", { enumerable: true, get: function () { return OINODbPostgresql_js_1.OINODbPostgresql; } });

package/dist/esm/OINODbPostgresql.js

@@ -0,0 +1,326 @@
+/*
+ * 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 { OINODb, OINODbDataSet, OINOBooleanDataField, OINONumberDataField, OINOStringDataField, OINO_ERROR_PREFIX, OINOBenchmark, OINODatetimeDataField, OINOBlobDataField, OINOLog } from "@oino-ts/db";
+import { Pool } from "pg";
+const EMPTY_ROW = [];
+/**
+ * Implmentation of OINODbDataSet for Postgresql.
+ *
+ */
+class OINOPostgresqlData extends OINODbDataSet {
+    _rows;
+    /**
+     * OINOPostgresqlData constructor
+     * @param params database parameters
+     */
+    constructor(data, messages = []) {
+        super(data, messages);
+        if ((data != null) && !(Array.isArray(data))) {
+            throw new Error(OINO_ERROR_PREFIX + ": Invalid Posgresql data type!"); // TODO: maybe check all rows
+        }
+        this._rows = data;
+        if (this.isEmpty()) {
+            this._currentRow = -1;
+            this._eof = true;
+        }
+        else {
+            this._currentRow = 0;
+            this._eof = false;
+        }
+    }
+    _currentRow;
+    _eof;
+    isEmpty() {
+        return (this._rows.length == 0);
+    }
+    // EOF means "there is no more content", i.e. either dataset is empty or we have moved beyond last line
+    isEof() {
+        return (this._eof);
+    }
+    next() {
+        // OINOLog.debug("OINODbDataSet.next", {currentRow:this._currentRow, length:this.sqlResult.data.length})
+        if (this._currentRow < this._rows.length - 1) {
+            this._currentRow = this._currentRow + 1;
+        }
+        else {
+            this._eof = true;
+        }
+        return !this._eof;
+    }
+    getRow() {
+        if ((this._currentRow >= 0) && (this._currentRow < this._rows.length)) {
+            return this._rows[this._currentRow];
+        }
+        else {
+            return EMPTY_ROW;
+        }
+    }
+}
+/**
+ * Implementation of Postgresql-database.
+ *
+ */
+export class OINODbPostgresql extends OINODb {
+    static table_schema_sql = `SELECT 
+    col.column_name, 
+    col.data_type, 
+    col.character_maximum_length, 
+    col.is_nullable, 
+    pk.primary_key,
+    col.numeric_precision,
+    col.numeric_scale,
+    col.column_default
+FROM information_schema.columns col
+LEFT JOIN LATERAL
+	(select kcu.column_name, 'YES' as primary_key
+	from 
+		information_schema.table_constraints tco,
+		information_schema.key_column_usage kcu 	 
+	where 
+		kcu.constraint_name = tco.constraint_name
+		and kcu.constraint_schema = tco.constraint_schema
+		and tco.table_name = col.table_name
+		and tco.constraint_type = 'PRIMARY KEY'
+	) pk on col.column_name = pk.column_name
+WHERE table_name = `;
+    // private _client:Client
+    _pool;
+    /**
+     * Constructor of `OINODbPostgresql`
+     * @param params database paraneters
+     */
+    constructor(params) {
+        super(params);
+        // OINOLog.debug("OINODbPostgresql.constructor", {params:params})
+        if (this._params.type !== "OINODbPostgresql") {
+            throw new Error(OINO_ERROR_PREFIX + ": Not OINODbPostgresql-type: " + this._params.type);
+        }
+        this._pool = new Pool({ host: params.url, database: params.database, port: params.port, user: params.user, password: params.password });
+        this._pool.on("error", (err) => {
+            OINOLog.error("OINODbPostgresql error", { err: err });
+        });
+        this._pool.on("connect", (message) => {
+            // OINOLog.info("OINODbPostgresql connect")
+        });
+        this._pool.on("release", (message) => {
+            // OINOLog.info("OINODbPostgresql notice")
+        });
+        this._pool.on("acquire", () => {
+            // OINOLog.info("OINODbPostgresql end")
+        });
+    }
+    _parseFieldLength(fieldLength) {
+        let result = parseInt((fieldLength || "0").toString());
+        if (Number.isNaN(result)) {
+            result = 0;
+        }
+        return result;
+    }
+    async _query(sql) {
+        // OINOLog.debug("OINODbPostgresql._query", {sql:sql})
+        const query_result = await this._pool.query({ rowMode: "array", text: sql });
+        // OINOLog.debug("OINODbPostgresql._query", {result:query_result})
+        return Promise.resolve(query_result.rows);
+    }
+    async _exec(sql) {
+        // OINOLog.debug("OINODbPostgresql._query", {sql:sql})
+        const query_result = await this._pool.query({ rowMode: "array", text: sql });
+        // OINOLog.debug("OINODbPostgresql._query", {result:query_result})
+        return Promise.resolve(query_result.rows);
+    }
+    /**
+     * Print a table name using database specific SQL escaping.
+     *
+     * @param sqlTable name of the table
+     *
+     */
+    printSqlTablename(sqlTable) {
+        return "\"" + sqlTable.toLowerCase() + "\"";
+    }
+    /**
+     * Print a column name with correct SQL escaping.
+     *
+     * @param sqlColumn name of the column
+     *
+     */
+    printSqlColumnname(sqlColumn) {
+        return "\"" + sqlColumn + "\"";
+    }
+    /**
+     * 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
+     *
+     */
+    printCellAsSqlValue(cellValue, sqlType) {
+        if (cellValue === null) {
+            return "NULL";
+        }
+        else if (cellValue === undefined) {
+            return "UNDEFINED";
+        }
+        else if ((sqlType == "integer") || (sqlType == "smallint") || (sqlType == "real")) {
+            return cellValue.toString();
+        }
+        else if (sqlType == "bytea") {
+            return "\'" + cellValue + "\'";
+        }
+        else if (sqlType == "boolean") {
+            if (cellValue == null || cellValue == "" || cellValue.toString().toLowerCase() == "false" || cellValue == "0") {
+                return "false";
+            }
+            else {
+                return "true";
+            }
+        }
+        else if ((sqlType == "date") && (cellValue instanceof Date)) {
+            return "\'" + cellValue.toISOString() + "\'";
+        }
+        else {
+            return "\'" + cellValue?.toString().replaceAll("'", "''") + "\'";
+        }
+    }
+    /**
+     * 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
+     *
+     */
+    parseSqlValueAsCell(sqlValue, sqlType) {
+        if ((sqlValue === null) || (sqlValue == "NULL")) {
+            return null;
+        }
+        else if ((sqlValue === undefined)) {
+            return undefined;
+        }
+        else if (((sqlType == "date")) && (typeof (sqlValue) == "string")) {
+            return new Date(sqlValue);
+        }
+        else {
+            return sqlValue;
+        }
+    }
+    /**
+     * Connect to database.
+     *
+     */
+    async connect() {
+        try {
+            // make sure that any items are correctly URL encoded in the connection string
+            // OINOLog.debug("OINODbPostgresql.connect")
+            // await this._pool.connect()
+            // await this._client.connect()
+            return Promise.resolve(true);
+        }
+        catch (err) {
+            // ... error checks
+            throw new Error(OINO_ERROR_PREFIX + ": Error connecting to Postgresql server: " + err);
+        }
+    }
+    /**
+     * Execute a select operation.
+     *
+     * @param sql SQL statement.
+     *
+     */
+    async sqlSelect(sql) {
+        OINOBenchmark.start("sqlSelect");
+        let result;
+        try {
+            const rows = await this._query(sql);
+            // OINOLog.debug("OINODbPostgresql.sqlSelect", {rows:rows})
+            result = new OINOPostgresqlData(rows, []);
+        }
+        catch (e) {
+            result = new OINOPostgresqlData([[]], [OINO_ERROR_PREFIX + " (sqlSelect): exception in _db.query [" + e.message + "]"]);
+        }
+        OINOBenchmark.end("sqlSelect");
+        return result;
+    }
+    /**
+     * Execute other sql operations.
+     *
+     * @param sql SQL statement.
+     *
+     */
+    async sqlExec(sql) {
+        OINOBenchmark.start("sqlExec");
+        let result;
+        try {
+            const rows = await this._exec(sql);
+            // OINOLog.debug("OINODbPostgresql.sqlExec", {rows:rows})
+            result = new OINOPostgresqlData(rows, []);
+        }
+        catch (e) {
+            result = new OINOPostgresqlData([[]], [OINO_ERROR_PREFIX + " (sqlExec): exception in _db.exec [" + e.message + "]"]);
+        }
+        OINOBenchmark.end("sqlExec");
+        return result;
+    }
+    /**
+     * Initialize a data model by getting the SQL schema and populating OINODbDataFields of
+     * the model.
+     *
+     * @param api api which data model to initialize.
+     *
+     */
+    async initializeApiDatamodel(api) {
+        const res = await this.sqlSelect(OINODbPostgresql.table_schema_sql + "'" + api.params.tableName.toLowerCase() + "';");
+        // OINOLog.debug("OINODbPostgresql.initializeApiDatamodel: table description ", {res: res })
+        while (!res.isEof()) {
+            const row = res.getRow();
+            // OINOLog.debug("OINODbPostgresql.initializeApiDatamodel: next row ", {row: row })
+            const field_name = row[0]?.toString() || "";
+            const sql_type = row[1]?.toString() || "";
+            const field_length = this._parseFieldLength(row[2]);
+            const numeric_precision = this._parseFieldLength(row[5]);
+            const numeric_scale = this._parseFieldLength(row[6]);
+            const default_val = row[7]?.toString() || "";
+            const field_params = {
+                isPrimaryKey: row[4] == "YES",
+                isNotNull: row[3] == "NO",
+                isAutoInc: default_val.startsWith("nextval(")
+            };
+            if ((!api.params.excludeFieldPrefix || !field_name.startsWith(api.params.excludeFieldPrefix)) && (!api.params.excludeFields || (api.params.excludeFields.indexOf(field_name) < 0))) {
+                // OINOLog.debug("OINODbPostgresql.initializeApiDatamodel: next field ", {field_name: field_name, sql_type:sql_type, field_length:field_length, field_params:field_params })
+                if ((sql_type == "integer") || (sql_type == "smallint") || (sql_type == "real")) {
+                    api.datamodel.addField(new OINONumberDataField(this, field_name, sql_type, field_params));
+                }
+                else if ((sql_type == "date")) {
+                    if (api.params.useDatesAsString) {
+                        api.datamodel.addField(new OINOStringDataField(this, field_name, sql_type, field_params, 0));
+                    }
+                    else {
+                        api.datamodel.addField(new OINODatetimeDataField(this, field_name, sql_type, field_params));
+                    }
+                }
+                else if ((sql_type == "character") || (sql_type == "character varying") || (sql_type == "varchar") || (sql_type == "text")) {
+                    api.datamodel.addField(new OINOStringDataField(this, field_name, sql_type, field_params, field_length));
+                }
+                else if ((sql_type == "bytea")) {
+                    api.datamodel.addField(new OINOBlobDataField(this, field_name, sql_type, field_params, field_length));
+                }
+                else if ((sql_type == "boolean")) {
+                    api.datamodel.addField(new OINOBooleanDataField(this, field_name, sql_type, field_params));
+                }
+                else if ((sql_type == "decimal") || (sql_type == "numeric")) {
+                    api.datamodel.addField(new OINOStringDataField(this, field_name, sql_type, field_params, numeric_precision + numeric_scale + 1));
+                }
+                else {
+                    OINOLog.info("OINODbPostgresql.initializeApiDatamodel: unrecognized field type treated as string", { field_name: field_name, sql_type: sql_type, field_length: field_length, field_params: field_params });
+                    api.datamodel.addField(new OINOStringDataField(this, field_name, sql_type, field_params, 0));
+                }
+            }
+            res.next();
+        }
+        OINOLog.debug("OINODbPostgresql.initializeDatasetModel:\n" + api.datamodel.printDebug("\n"));
+        return Promise.resolve();
+    }
+}

package/dist/esm/index.js

@@ -0,0 +1 @@
+export { OINODbPostgresql } from "./OINODbPostgresql.js";

package/dist/types/OINODbPostgresql.d.ts

@@ -0,0 +1,76 @@
+import { OINODb, OINODbParams, OINODbDataSet, OINODbApi, OINODataCell } from "@oino-ts/db";
+/**
+ * Implementation of Postgresql-database.
+ *
+ */
+export declare class OINODbPostgresql extends OINODb {
+    private static table_schema_sql;
+    private _pool;
+    /**
+     * Constructor of `OINODbPostgresql`
+     * @param params database paraneters
+     */
+    constructor(params: OINODbParams);
+    private _parseFieldLength;
+    private _query;
+    private _exec;
+    /**
+     * Print a table name using database specific SQL escaping.
+     *
+     * @param sqlTable name of the table
+     *
+     */
+    printSqlTablename(sqlTable: string): string;
+    /**
+     * Print a column name with correct SQL escaping.
+     *
+     * @param sqlColumn name of the column
+     *
+     */
+    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
+     *
+     */
+    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
+     *
+     */
+    parseSqlValueAsCell(sqlValue: OINODataCell, sqlType: string): OINODataCell;
+    /**
+     * Connect to database.
+     *
+     */
+    connect(): Promise<boolean>;
+    /**
+     * Execute a select operation.
+     *
+     * @param sql SQL statement.
+     *
+     */
+    sqlSelect(sql: string): Promise<OINODbDataSet>;
+    /**
+     * Execute other sql operations.
+     *
+     * @param sql SQL statement.
+     *
+     */
+    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.
+     *
+     */
+    initializeApiDatamodel(api: OINODbApi): Promise<void>;
+}

package/dist/types/index.d.ts

@@ -0,0 +1 @@
+export { OINODbPostgresql } from "./OINODbPostgresql.js";

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@oino-ts/db-postgresql",
+  "version": "0.0.11",
+  "description": "OINO TS package for using Postgresql databases.",
+  "author": "Matias Kiviniemi (pragmatta)",
+  "license": "MPL-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/pragmatta/oino-ts.git"
+  },
+  "keywords": [
+    "sql",
+    "database",
+    "rest-api",
+    "typescript",
+    "library",
+    "postgresql"
+  ],
+  "main": "./dist/cjs/index.js",
+  "module": "./dist/esm/index.js",
+  "types": "./dist/types/index.d.ts",
+  "dependencies": {
+    "@oino-ts/db": "^0.0.11",
+    "pg": "^8.11.3"
+  },
+  "devDependencies": {
+    "@types/node": "^20.12.7",
+    "@types/pg": "^8.11.5",
+    "@types/bun": "latest"
+  },
+  "files": [
+    "src/*.ts",
+    "dist/cjs/*.js",
+    "dist/esm/*.js",
+    "dist/types/*.d.ts"
+  ]
+}

package/src/OINODbPostgresql.ts

@@ -0,0 +1,351 @@
+/*
+ * 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 { OINODb, OINODbParams, OINODbDataSet, OINODbApi, OINOBooleanDataField, OINONumberDataField, OINOStringDataField, OINODbDataFieldParams, OINO_ERROR_PREFIX, OINODataRow, OINODataCell, OINOBenchmark, OINODatetimeDataField, OINOBlobDataField, OINOLog } from "@oino-ts/db";
+
+import { Pool, QueryResult } from "pg";
+
+const EMPTY_ROW:string[] = []
+
+/**
+ * Implmentation of OINODbDataSet for Postgresql.
+ * 
+ */
+class OINOPostgresqlData extends OINODbDataSet {
+    private _rows:OINODataRow[]
+    
+    /**
+     * OINOPostgresqlData constructor
+     * @param params database parameters
+     */
+    constructor(data: unknown, messages:string[]=[]) {
+        super(data, messages)
+
+        if ((data != null) && !(Array.isArray(data))) {
+            throw new Error(OINO_ERROR_PREFIX + ": Invalid Posgresql data type!") // TODO: maybe check all rows
+        }
+        this._rows = data as OINODataRow[]
+        if (this.isEmpty()) {
+            this._currentRow = -1
+            this._eof = true
+        } else {
+            this._currentRow = 0
+            this._eof = false
+        }
+    }
+    private _currentRow: number
+    private _eof: boolean
+    isEmpty():boolean {
+        return (this._rows.length == 0)
+    }
+
+    // EOF means "there is no more content", i.e. either dataset is empty or we have moved beyond last line
+    isEof():boolean {
+        return (this._eof)
+    }
+
+    next():boolean {
+        // OINOLog.debug("OINODbDataSet.next", {currentRow:this._currentRow, length:this.sqlResult.data.length})
+        if (this._currentRow < this._rows.length-1) {
+            this._currentRow = this._currentRow + 1
+        } else {
+            this._eof = true
+        }
+        return !this._eof
+    }
+
+    getRow(): OINODataRow {
+        if ((this._currentRow >=0) && (this._currentRow < this._rows.length)) {
+            return this._rows[this._currentRow]
+        } else {
+            return EMPTY_ROW
+        }
+    }
+}
+
+/**
+ * Implementation of Postgresql-database.
+ * 
+ */
+export class OINODbPostgresql extends OINODb {
+    
+    private static table_schema_sql:string =
+`SELECT 
+    col.column_name, 
+    col.data_type, 
+    col.character_maximum_length, 
+    col.is_nullable, 
+    pk.primary_key,
+    col.numeric_precision,
+    col.numeric_scale,
+    col.column_default
+FROM information_schema.columns col
+LEFT JOIN LATERAL
+	(select kcu.column_name, 'YES' as primary_key
+	from 
+		information_schema.table_constraints tco,
+		information_schema.key_column_usage kcu 	 
+	where 
+		kcu.constraint_name = tco.constraint_name
+		and kcu.constraint_schema = tco.constraint_schema
+		and tco.table_name = col.table_name
+		and tco.constraint_type = 'PRIMARY KEY'
+	) pk on col.column_name = pk.column_name
+WHERE table_name = `
+    
+    // private _client:Client
+    private _pool:Pool
+
+    /**
+     * Constructor of `OINODbPostgresql`
+     * @param params database paraneters
+     */
+    constructor(params:OINODbParams) {
+        super(params)
+
+        // OINOLog.debug("OINODbPostgresql.constructor", {params:params})
+        if (this._params.type !== "OINODbPostgresql") {
+            throw new Error(OINO_ERROR_PREFIX + ": Not OINODbPostgresql-type: " + this._params.type)
+        } 
+        this._pool = new Pool({ host: params.url, database: params.database, port: params.port, user: params.user, password: params.password })
+        this._pool.on("error", (err: any) => {
+            OINOLog.error("OINODbPostgresql error", {err:err})
+        })
+        this._pool.on("connect", (message: any) => {
+            // OINOLog.info("OINODbPostgresql connect")
+        })
+        this._pool.on("release", (message: any) => {
+            // OINOLog.info("OINODbPostgresql notice")
+        })
+        this._pool.on("acquire", () => {
+            // OINOLog.info("OINODbPostgresql end")
+        })
+    }
+
+    private _parseFieldLength(fieldLength:OINODataCell):number {
+        let result:number = parseInt((fieldLength || "0").toString())
+        if (Number.isNaN(result)) {
+            result = 0
+        }
+        return result
+    }
+
+    private async _query(sql:string):Promise<OINODataRow[]> {
+        // OINOLog.debug("OINODbPostgresql._query", {sql:sql})
+        const query_result:QueryResult = await this._pool.query({rowMode: "array", text: sql})
+        // OINOLog.debug("OINODbPostgresql._query", {result:query_result})
+        return Promise.resolve(query_result.rows)
+    }
+
+    private async _exec(sql:string):Promise<OINODataRow[]> {
+        // OINOLog.debug("OINODbPostgresql._query", {sql:sql})
+        const query_result:QueryResult = await this._pool.query({rowMode: "array", text: sql})
+        // OINOLog.debug("OINODbPostgresql._query", {result:query_result})
+        return Promise.resolve(query_result.rows)
+    }
+
+    /**
+     * Print a table name using database specific SQL escaping.
+     * 
+     * @param sqlTable name of the table
+     *
+     */
+    printSqlTablename(sqlTable:string): string {
+        return "\""+sqlTable.toLowerCase()+"\""
+    }
+
+    /**
+     * Print a column name with correct SQL escaping.
+     * 
+     * @param sqlColumn name of the column
+     *
+     */
+    printSqlColumnname(sqlColumn:string): string {
+        return "\""+sqlColumn+"\""
+    }
+
+    /**
+     * 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
+     *
+     */
+    printCellAsSqlValue(cellValue:OINODataCell, sqlType: string): string {
+        if (cellValue === null) {
+            return "NULL"
+
+        } else if (cellValue === undefined) {
+            return "UNDEFINED"
+
+        } else if ((sqlType == "integer") || (sqlType == "smallint") || (sqlType == "real")) {
+            return cellValue.toString()
+
+        } else if (sqlType == "bytea") {
+            return "\'" + cellValue + "\'"
+
+        } else if (sqlType == "boolean") {
+            if (cellValue == null || cellValue == "" || cellValue.toString().toLowerCase() == "false" || cellValue == "0") { 
+                return "false"
+            } else {
+                return "true"
+            }
+
+        } else if ((sqlType == "date") && (cellValue instanceof Date)) {
+            return "\'" + cellValue.toISOString() + "\'"
+
+        } else {
+            return "\'" + cellValue?.toString().replaceAll("'", "''") + "\'"
+        }
+    }
+
+    /**
+     * 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
+     * 
+     */
+    parseSqlValueAsCell(sqlValue:OINODataCell, sqlType: string): OINODataCell {
+        if ((sqlValue === null) || (sqlValue == "NULL")) {
+            return null
+
+        } else if ((sqlValue === undefined)) {
+            return undefined
+
+        } else if (((sqlType == "date")) && (typeof(sqlValue) == "string")) {
+            return new Date(sqlValue)
+
+        } else {
+            return sqlValue
+        }
+
+    }
+
+    /**
+     * Connect to database.
+     *
+     */
+    async connect(): Promise<boolean> {
+        try {
+            // make sure that any items are correctly URL encoded in the connection string
+            // OINOLog.debug("OINODbPostgresql.connect")
+            // await this._pool.connect()
+            // await this._client.connect()
+            return Promise.resolve(true)
+        } catch (err) {
+            // ... error checks
+            throw new Error(OINO_ERROR_PREFIX + ": Error connecting to Postgresql server: " + err)
+        }        
+    }
+
+    /**
+     * Execute a select operation.
+     * 
+     * @param sql SQL statement.
+     *
+     */
+    async sqlSelect(sql:string): Promise<OINODbDataSet> {
+        OINOBenchmark.start("sqlSelect")
+        let result:OINODbDataSet
+        try {
+            const rows:OINODataRow[] = await this._query(sql)
+            // OINOLog.debug("OINODbPostgresql.sqlSelect", {rows:rows})
+            result = new OINOPostgresqlData(rows, [])
+
+        } catch (e:any) {
+            result = new OINOPostgresqlData([[]], [OINO_ERROR_PREFIX + " (sqlSelect): exception in _db.query [" + e.message + "]"])
+        }
+        OINOBenchmark.end("sqlSelect")
+        return result
+    }
+
+    /**
+     * Execute other sql operations.
+     * 
+     * @param sql SQL statement.
+     *
+     */
+    async sqlExec(sql:string): Promise<OINODbDataSet> {
+        OINOBenchmark.start("sqlExec")
+        let result:OINODbDataSet
+        try {
+            const rows:OINODataRow[] = await this._exec(sql)
+            // OINOLog.debug("OINODbPostgresql.sqlExec", {rows:rows})
+            result = new OINOPostgresqlData(rows, [])
+
+        } catch (e:any) {
+            result = new OINOPostgresqlData([[]], [OINO_ERROR_PREFIX + " (sqlExec): exception in _db.exec [" + e.message + "]"])
+        }
+        OINOBenchmark.end("sqlExec")
+        return result
+    }
+
+    /**
+     * Initialize a data model by getting the SQL schema and populating OINODbDataFields of 
+     * the model.
+     * 
+     * @param api api which data model to initialize.
+     *
+     */
+    async initializeApiDatamodel(api:OINODbApi): Promise<void> {
+        
+        const res:OINODbDataSet = await this.sqlSelect(OINODbPostgresql.table_schema_sql + "'" + api.params.tableName.toLowerCase() + "';")
+        // OINOLog.debug("OINODbPostgresql.initializeApiDatamodel: table description ", {res: res })
+        while (!res.isEof()) {
+            const row:OINODataRow = res.getRow()
+            // OINOLog.debug("OINODbPostgresql.initializeApiDatamodel: next row ", {row: row })
+            const field_name:string = row[0]?.toString() || ""
+            const sql_type:string = row[1]?.toString() || ""
+            const field_length:number = this._parseFieldLength(row[2])
+            const numeric_precision:number = this._parseFieldLength(row[5])
+            const numeric_scale:number = this._parseFieldLength(row[6])
+            const default_val:string = row[7]?.toString() || ""
+            const field_params:OINODbDataFieldParams = {
+                isPrimaryKey: row[4] == "YES",
+                isNotNull: row[3] == "NO",
+                isAutoInc: default_val.startsWith("nextval(")
+            }            
+            if ((!api.params.excludeFieldPrefix || !field_name.startsWith(api.params.excludeFieldPrefix)) && (!api.params.excludeFields || (api.params.excludeFields.indexOf(field_name) < 0))) {
+                // OINOLog.debug("OINODbPostgresql.initializeApiDatamodel: next field ", {field_name: field_name, sql_type:sql_type, field_length:field_length, field_params:field_params })
+                if ((sql_type == "integer") || (sql_type == "smallint") || (sql_type == "real")) {
+                    api.datamodel.addField(new OINONumberDataField(this, field_name, sql_type, field_params ))
+
+                } else if ((sql_type == "date")) {
+                    if (api.params.useDatesAsString) {
+                        api.datamodel.addField(new OINOStringDataField(this, field_name, sql_type, field_params, 0))
+                    } else {
+                        api.datamodel.addField(new OINODatetimeDataField(this, field_name, sql_type, field_params))
+                    }
+
+                } else if ((sql_type == "character") || (sql_type == "character varying") || (sql_type == "varchar") || (sql_type == "text")) {
+                    api.datamodel.addField(new OINOStringDataField(this, field_name, sql_type, field_params, field_length))
+
+                } else if ((sql_type == "bytea")) {
+                    api.datamodel.addField(new OINOBlobDataField(this, field_name, sql_type, field_params, field_length))
+
+                } else if ((sql_type == "boolean")) {
+                    api.datamodel.addField(new OINOBooleanDataField(this, field_name, sql_type, field_params))
+
+                } else if ((sql_type == "decimal") || (sql_type == "numeric")) {
+                    api.datamodel.addField(new OINOStringDataField(this, field_name, sql_type, field_params, numeric_precision + numeric_scale + 1))
+
+                } else {
+                    OINOLog.info("OINODbPostgresql.initializeApiDatamodel: unrecognized field type treated as string", {field_name: field_name, sql_type:sql_type, field_length:field_length, field_params:field_params })
+                    api.datamodel.addField(new OINOStringDataField(this, field_name, sql_type, field_params, 0))
+                }   
+            }
+            res.next()
+        }
+        OINOLog.debug("OINODbPostgresql.initializeDatasetModel:\n" + api.datamodel.printDebug("\n"))
+        return Promise.resolve()
+    }
+}
+
+
+

package/src/index.ts

@@ -0,0 +1 @@
+export { OINODbPostgresql } from "./OINODbPostgresql.js"