@oino-ts/db 0.1.2 → 0.2.0

package/dist/types/OINODb.d.ts

@@ -0,0 +1,180 @@
+import { OINODbParams, OINODbApi, OINODataCell, OINODataRow } from "./index.js";
+/**
+ * Base class for database abstraction, implementing methods for connecting, making queries and parsing/formatting data
+ * between SQL and serialization formats.
+ *
+ */
+export declare abstract class OINODb {
+    protected _params: OINODbParams;
+    /** Name of the database */
+    readonly name: string;
+    /**
+     * Constructor for `OINODb`.
+     * @param params database parameters
+     */
+    constructor(params: OINODbParams);
+    /**
+     * Connect to database.
+     *
+     */
+    abstract connect(): Promise<boolean>;
+    /**
+     * Print a table name using database specific SQL escaping.
+     *
+     * @param sqlTable name of the table
+     *
+     */
+    abstract printSqlTablename(sqlTable: string): string;
+    /**
+     * Print a column name with correct SQL escaping.
+     *
+     * @param sqlColumn name of the column
+     *
+     */
+    abstract printSqlColumnname(sqlColumn: string): string;
+    /**
+     * Print a single data value from serialization using the context of the native data
+     * type with the correct SQL escaping.
+     *
+     * @param cellValue data from sql results
+     * @param sqlType native type name for table column
+     *
+     */
+    abstract printCellAsSqlValue(cellValue: OINODataCell, sqlType: string): string;
+    /**
+     * Parse a single SQL result value for serialization using the context of the native data
+     * type.
+     *
+     * @param sqlValue data from serialization
+     * @param sqlType native type name for table column
+     *
+     */
+    abstract parseSqlValueAsCell(sqlValue: OINODataCell, sqlType: string): OINODataCell;
+    /**
+     * Execute a select operation.
+     *
+     * @param sql SQL statement.
+     *
+     */
+    abstract sqlSelect(sql: string): Promise<OINODbDataSet>;
+    /**
+     * Execute other sql operations.
+     *
+     * @param sql SQL statement.
+     *
+     */
+    abstract sqlExec(sql: string): Promise<OINODbDataSet>;
+    /**
+     * Initialize a data model by getting the SQL schema and populating OINODbDataFields of
+     * the model.
+     *
+     * @param api api which data model to initialize.
+     *
+     */
+    abstract initializeApiDatamodel(api: OINODbApi): Promise<void>;
+    /**
+     * Print SQL select statement with DB specific formatting.
+     *
+     * @param tableName - The name of the table to select from.
+     * @param columnNames - The columns to be selected.
+     * @param whereCondition - The WHERE clause to filter the results.
+     * @param orderCondition - The ORDER BY clause to sort the results.
+     * @param limitCondition - The LIMIT clause to limit the number of results.
+     *
+     */
+    printSqlSelect(tableName: string, columnNames: string, whereCondition: string, orderCondition: string, limitCondition: string): string;
+}
+/**
+ * Base class for SQL results that can be asynchronously iterated (but
+ * not necessarity rewinded). Idea is to handle database specific mechanisms
+ * for returning and formatting conventions in the database specific
+ * implementation. Data might be in memory or streamed in chunks and
+ * `OINODbDataSet` will serve it out consistently.
+ *
+ */
+export declare abstract class OINODbDataSet {
+    private _data;
+    /** Error messages */
+    readonly messages: string[];
+    /**
+     * Constructor for `OINODbDataSet`.
+     *
+     * @param data internal database specific data type (constructor will throw if invalid)
+     * @param messages error messages from SQL-query
+     *
+     */
+    constructor(data: unknown, messages?: string[]);
+    /**
+     * Is data set empty.
+     *
+     */
+    abstract isEmpty(): boolean;
+    /**
+     * Is there no more content, i.e. either dataset is empty or we have moved beyond last line
+     *
+     */
+    abstract isEof(): boolean;
+    /**
+     * Attempts to moves dataset to the next row, possibly waiting for more data to become available. Returns !isEof().
+     *
+     */
+    abstract next(): Promise<boolean>;
+    /**
+     * Gets current row of data.
+     *
+     */
+    abstract getRow(): OINODataRow;
+    /**
+     * Checks if the messages contain errors.
+     *
+     */
+    hasErrors(): boolean;
+    /**
+     * Checks if the messages contain errors.
+     *
+     */
+    getFirstError(): string;
+}
+/**
+ * Generic in memory implementation of a data set where data is an array of rows. Used
+ * by BunSqlite and automated testing. Can be rewinded.
+ *
+ */
+export declare class OINODbMemoryDataSet extends OINODbDataSet {
+    private _rows;
+    private _currentRow;
+    private _eof;
+    /**
+     * Constructor of `OINODbMemoryDataSet`.
+     *
+     * @param data data as OINODataRow[] (constructor will throw if invalid)
+     * @param errors error messages from SQL-query
+     *
+     */
+    constructor(data: unknown, errors?: string[]);
+    /**
+     * Is data set empty.
+     *
+     */
+    isEmpty(): boolean;
+    /**
+     * Is there no more content, i.e. either dataset is empty or we have moved beyond last line
+     *
+     */
+    isEof(): boolean;
+    /**
+     * Attempts to moves dataset to the next row, possibly waiting for more data to become available. Returns !isEof().
+     *
+     */
+    next(): Promise<boolean>;
+    /**
+     * Gets current row of data.
+     *
+     */
+    getRow(): OINODataRow;
+    /**
+     * Rewinds data set to the first row, returns !isEof().
+     *
+     */
+    first(): boolean;
+}

package/dist/types/OINODbApi.d.ts

@@ -0,0 +1,82 @@
+import { OINODbApiParams, OINODb, OINODbDataModel, OINODataRow, OINODbModelSet, OINODbApiRequestParams, OINOHttpResult, OINOHtmlTemplate } from "./index.js";
+import { OINOResult } from "@oino-ts/common";
+import { OINOHashid } from "@oino-ts/hashid";
+/**
+ * OINO API request result object with returned data and/or http status code/message and
+ * error / warning messages.
+ *
+ */
+export declare class OINODbApiResult extends OINOResult {
+    /** DbApi request params */
+    params: OINODbApiRequestParams;
+    /** Returned data if any */
+    data?: OINODbModelSet;
+    /**
+     * Constructor of OINODbApiResult.
+     *
+     * @param params DbApi request parameters
+     * @param data result data
+     *
+     */
+    constructor(params: OINODbApiRequestParams, data?: OINODbModelSet);
+    /**
+     * Creates a HTTP Response from API results.
+     *
+     * @param headers Headers to include in the response
+     *
+     */
+    getResponse(headers?: Record<string, string>): Promise<Response>;
+}
+/**
+ * Specialized HTML template that can render ´OINODbApiResult´.
+ *
+ */
+export declare class OINODbHtmlTemplate extends OINOHtmlTemplate {
+    /**
+     * Creates HTML Response from API modelset.
+     *
+     * @param modelset OINO API dataset
+     * @param overrideValues values to override in the data
+     *
+     */
+    renderFromDbData(modelset: OINODbModelSet, overrideValues?: any): Promise<OINOHttpResult>;
+}
+/**
+ * API class with method to process HTTP REST requests.
+ *
+ */
+export declare class OINODbApi {
+    /** API database reference */
+    readonly db: OINODb;
+    /** API datamodel */
+    readonly datamodel: OINODbDataModel;
+    /** API parameters */
+    readonly params: OINODbApiParams;
+    /** API hashid */
+    readonly hashid: OINOHashid | null;
+    /**
+     * Constructor of API object.
+     * NOTE! OINODb.initDatamodel must be called if created manually instead of the factory.
+     *
+     * @param db database for the API
+     * @param params parameters for the API
+     *
+     */
+    constructor(db: OINODb, params: OINODbApiParams);
+    private _validateRowValues;
+    private _doGet;
+    private _doPost;
+    private _doPut;
+    private _doDelete;
+    /**
+     * Method for handlind a HTTP REST request with GET, POST, PUT, DELETE corresponding to
+     * SQL select, insert, update and delete.
+     *
+     * @param method HTTP verb (uppercase)
+     * @param id URL id of the REST request
+     * @param body HTTP body data as either serialized string or unserialized JS object / OINODataRow-array
+     * @param params HTTP URL parameters as key-value-pairs
+     *
+     */
+    doRequest(method: string, id: string, body: string | OINODataRow[] | Buffer | any, params?: OINODbApiRequestParams): Promise<OINODbApiResult>;
+}

package/dist/types/OINODbConfig.d.ts

@@ -0,0 +1,52 @@
+/** Set the name of the OINO ID field (default \_OINOID\_) */
+export declare class OINODbConfig {
+    /** Name of the synthetic OINO ID field */
+    static OINODB_ID_FIELD: string;
+    /** Private key separator of the synthetic OINO ID field */
+    static OINODB_ID_SEPARATOR: string;
+    private static OINODB_ID_SEPARATOR_ESCAPED;
+    /** Name of the OINODbSqlFilter-parameter in request */
+    static OINODB_SQL_FILTER_PARAM: string;
+    /** Name of the OINODbSqlOrder-parameter in request */
+    static OINODB_SQL_ORDER_PARAM: string;
+    /** Name of the OINODbSqlLimit-parameter in request */
+    static OINODB_SQL_LIMIT_PARAM: string;
+    /**
+     * Set the name of the OINO ID field
+     * @param idField name of the OINO ID field
+     */
+    static setOinoIdField(idField: string): void;
+    /**
+     * Set the separator character of the OINO ID field
+     * @param idSeparator character to use as separator of id parts
+    */
+    static setOinoIdSeparator(idSeparator: string): void;
+    /**
+     * Print OINO ID for primary key values.
+     *
+     * @param primaryKeys an array of primary key values.
+     *
+     */
+    static printOINOId(primaryKeys: string[]): string;
+    /**
+     * Set the name of the OINODbSqlFilter-param field
+     *
+     * @param sqlFilterParam name of the http parameter with `OINODbSqlFilter` definition
+     *
+     */
+    static setOinoSqlFilterParam(sqlFilterParam: string): void;
+    /**
+     * Set the name of the OINODbSqlOrder-param field
+     *
+     * @param sqlOrderParam name of the http parameter with `OINODbSqlOrder` definition
+     *
+     */
+    static setOinoSqlOrderParam(sqlOrderParam: string): void;
+    /**
+     * Set the name of the OINODbSqlLimit-param field
+     *
+     * @param sqlLimitParam name of the http parameter with `OINODbSqlLimit` definition
+     *
+     */
+    static setOinoSqlLimitParam(sqlLimitParam: string): void;
+}

package/dist/types/OINODbDataField.d.ts

@@ -0,0 +1,202 @@
+import { OINODbDataFieldParams, OINODataCell, OINODb } from "./index.js";
+/**
+ * Base class for a column of data responsible for appropriatelly serializing/deserializing the data.
+ *
+ */
+export declare class OINODbDataField {
+    /** OINODB reference*/
+    readonly db: OINODb;
+    /** Name of the field */
+    readonly name: string;
+    /** Internal type of field*/
+    readonly type: string;
+    /** SQL type of the field */
+    readonly sqlType: string;
+    /** Maximum length of the field (or 0) */
+    readonly maxLength: number;
+    /** Parameters for the field */
+    readonly fieldParams: OINODbDataFieldParams;
+    /**
+     * Constructor for a data field
+     *
+     * @param db OINODb reference
+     * @param name name of the field
+     * @param type internal type of the field
+     * @param sqlType column type in database
+     * @param fieldParams parameters of the field
+     * @param maxLength maximum length of the field (or 0)
+     *
+     */
+    constructor(db: OINODb, name: string, type: string, sqlType: string, fieldParams: OINODbDataFieldParams, maxLength?: number);
+    /**
+     * Pring debug information for the field
+     *
+     * @param length length of the debug output (or 0 for as long as needed)
+     *
+     */
+    printColumnDebug(length?: number): string;
+    /**
+     * Serialize cell value in the given content format.
+     *
+     * @param cellVal cell value
+     *
+     */
+    serializeCell(cellVal: OINODataCell): string | null | undefined;
+    /**
+     * Parce cell value from string using field type specific formatting rules.
+     *
+     * @param value string value
+     *
+     */
+    deserializeCell(value: string | null | undefined): OINODataCell;
+    /**
+     * Print data cell (from deserialization) as SQL-string.
+     *
+     * @param cellVal cell value
+     *
+     */
+    printCellAsSqlValue(cellVal: OINODataCell): string;
+    /**
+     * Print name of column as SQL.
+     *
+     */
+    printSqlColumnName(): string;
+}
+/**
+ * Specialised class for a string column.
+ *
+ */
+export declare class OINOStringDataField extends OINODbDataField {
+    /**
+     * Constructor for a string data field
+     *
+     * @param db OINODb reference
+     * @param name name of the field
+     * @param sqlType column type in database
+     * @param fieldParams parameters of the field
+     * @param maxLength maximum length of the field (or 0)
+     *
+     */
+    constructor(db: OINODb, name: string, sqlType: string, fieldParams: OINODbDataFieldParams, maxLength: number);
+}
+/**
+ * Specialised class for a boolean column.
+ *
+ */
+export declare class OINOBooleanDataField extends OINODbDataField {
+    /**
+     * Constructor for a boolean data field
+     *
+     * @param db OINODb reference
+     * @param name name of the field
+     * @param sqlType column type in database
+     * @param fieldParams parameters of the field
+     *
+     */
+    constructor(db: OINODb, name: string, sqlType: string, fieldParams: OINODbDataFieldParams);
+    /**
+     * Serialize cell value in the given content format.
+     *
+     * @param cellVal cell value
+     *
+     */
+    serializeCell(cellVal: OINODataCell): string | null | undefined;
+    /**
+     * Parce cell value from string using field type specific formatting rules.
+     *
+     * @param value string value
+     *
+     */
+    deserializeCell(value: string | null | undefined): OINODataCell;
+}
+/**
+ * Specialised class for a number column.
+ *
+ */
+export declare class OINONumberDataField extends OINODbDataField {
+    /**
+     * Constructor for a string data field
+     *
+     * @param db OINODb reference
+     * @param name name of the field
+     * @param sqlType column type in database
+     * @param fieldParams parameters of the field
+     *
+     */
+    constructor(db: OINODb, name: string, sqlType: string, fieldParams: OINODbDataFieldParams);
+    /**
+     * Serialize cell value in the given content format.
+     *
+     * @param cellVal cell value
+     *
+     */
+    serializeCell(cellVal: OINODataCell): string | null | undefined;
+    /**
+     * Parce cell value from string using field type specific formatting rules.
+     *
+     * @param value string value
+     *
+     */
+    deserializeCell(value: string | null | undefined): OINODataCell;
+}
+/**
+ * Specialised class for a blob column.
+ *
+ */
+export declare class OINOBlobDataField extends OINODbDataField {
+    /**
+     * Constructor for a blob data field
+     *
+     * @param db OINODb reference
+     * @param name name of the field
+     * @param sqlType column type in database
+     * @param fieldParams parameters of the field
+     * @param maxLength maximum length of the field (or 0)
+     *
+     */
+    constructor(db: OINODb, name: string, sqlType: string, fieldParams: OINODbDataFieldParams, maxLength: number);
+    /**
+     * Serialize cell value in the given content format.
+     *
+     * @param cellVal cell value
+     *
+     */
+    serializeCell(cellVal: OINODataCell): string | null | undefined;
+    /**
+     * Parce cell value from string using field type specific formatting rules.
+     *
+     * @param value string value
+     *
+     */
+    deserializeCell(value: string | null | undefined): OINODataCell;
+}
+/**
+ * Specialised class for a datetime column.
+ *
+ */
+export declare class OINODatetimeDataField extends OINODbDataField {
+    /**
+     * Constructor for a string data field
+     *
+     * @param db OINODb reference
+     * @param name name of the field
+     * @param sqlType column type in database
+     * @param fieldParams parameters of the field
+     *
+     */
+    constructor(db: OINODb, name: string, sqlType: string, fieldParams: OINODbDataFieldParams);
+    /**
+     * Serialize cell value in the given content format.
+     *
+     * @param cellVal cell value
+     *
+     */
+    serializeCell(cellVal: OINODataCell): string | null | undefined;
+    /**
+     * Parce cell value from string using field type specific formatting rules.
+     *
+     * @param value string value
+     *
+     */
+    deserializeCell(value: string | null | undefined): OINODataCell;
+}

package/dist/types/OINODbDataModel.d.ts

@@ -0,0 +1,108 @@
+import { OINODbDataField, OINODbApi, OINODataRow, OINODbDataFieldFilter, OINODbSqlParams } from "./index.js";
+/**
+ * OINO Datamodel object for representing one database table and it's columns.
+ *
+ */
+export declare class OINODbDataModel {
+    private _columnLookup;
+    /** Database refererence of the table */
+    readonly api: OINODbApi;
+    /** Field refererences of the API */
+    readonly fields: OINODbDataField[];
+    /**
+     * Constructor of the data model.
+     * NOTE! OINODbDataModel.initialize must be called after constructor to populate fields.
+     *
+     * @param api api of the data model
+     *
+     */
+    constructor(api: OINODbApi);
+    /**
+     * Initialize datamodel from SQL schema.
+     *
+     */
+    initialize(): Promise<void>;
+    private _printSqlColumnNames;
+    private _printSqlInsertColumnsAndValues;
+    private _printSqlUpdateValues;
+    private _printSqlPrimaryKeyCondition;
+    /**
+     * Add a field to the datamodel.
+     *
+     * @param field dataset field
+     *
+     */
+    addField(field: OINODbDataField): void;
+    /**
+     * Find a field of a given name if any.
+     *
+     * @param name name of the field to find
+     *
+     */
+    findFieldByName(name: string): OINODbDataField | null;
+    /**
+     * Find index of a field of a given name if any.
+     *
+     * @param name name of the field to find
+     *
+     */
+    findFieldIndexByName(name: string): number;
+    /**
+     * Find all fields based of given filter callback criteria (e.g. fields of certain data type, primary keys etc.)
+     *
+     * @param filter callback called for each field to include or not
+     *
+     */
+    filterFields(filter: OINODbDataFieldFilter): OINODbDataField[];
+    /**
+     * Return the primary key values of one row in order of the data model
+     *
+     * @param row data row
+     * @param hashidValues apply hashid when applicable
+     *
+     */
+    getRowPrimarykeyValues(row: OINODataRow, hashidValues?: boolean): string[];
+    /**
+     * Print debug information about the fields.
+     *
+     * @param separator string to separate field prints
+     *
+     */
+    printDebug(separator?: string): string;
+    /**
+     * Print all public properties (db, table name, fields) of the datamodel. Used
+     * in automated testing validate schema has stayed the same.
+     *
+     */
+    printFieldPublicPropertiesJson(): string;
+    /**
+     * Print SQL select statement using optional id and filter.
+     *
+     * @param id OINO ID (i.e. combined primary key values)
+     * @param params OINO reqest params
+     *
+     */
+    printSqlSelect(id: string, params: OINODbSqlParams): string;
+    /**
+     * Print SQL insert statement from one data row.
+     *
+     * @param row one row of data in the data model
+     *
+     */
+    printSqlInsert(row: OINODataRow): string;
+    /**
+     * Print SQL insert statement from one data row.
+     *
+     * @param id OINO ID (i.e. combined primary key values)
+     * @param row one row of data in the data model
+     *
+     */
+    printSqlUpdate(id: string, row: OINODataRow): string;
+    /**
+     * Print SQL delete statement for id.
+     *
+     * @param id OINO ID (i.e. combined primary key values)
+     *
+     */
+    printSqlDelete(id: string): string;
+}

package/dist/types/OINODbDataSet.d.ts

@@ -0,0 +1,95 @@
+import { OINODataRow } from "./index.js";
+/**
+ * Base class for SQL results that can be asynchronously iterated (but
+ * not necessarity rewinded). Idea is to handle database specific mechanisms
+ * for returning and formatting conventions in the database specific
+ * implementation. Data might be in memory or streamed in chunks and
+ * `OINODbDataSet` will serve it out consistently.
+ *
+ */
+export declare abstract class OINODbDataSet {
+    private _data;
+    /** Error messages */
+    readonly messages: string[];
+    /**
+     * Constructor for `OINODbDataSet`.
+     *
+     * @param data internal database specific data type (constructor will throw if invalid)
+     * @param messages error messages from SQL-query
+     *
+     */
+    constructor(data: unknown, messages?: string[]);
+    /**
+     * Is data set empty.
+     *
+     */
+    abstract isEmpty(): boolean;
+    /**
+     * Is there no more content, i.e. either dataset is empty or we have moved beyond last line
+     *
+     */
+    abstract isEof(): boolean;
+    /**
+     * Attempts to moves dataset to the next row, possibly waiting for more data to become available. Returns !isEof().
+     *
+     */
+    abstract next(): Promise<boolean>;
+    /**
+     * Gets current row of data.
+     *
+     */
+    abstract getRow(): OINODataRow;
+    /**
+     * Checks if the messages contain errors.
+     *
+     */
+    hasErrors(): boolean;
+    /**
+     * Checks if the messages contain errors.
+     *
+     */
+    getFirstError(): string;
+}
+/**
+ * Generic in memory implementation of a data set where data is an array of rows. Used
+ * by BunSqlite and automated testing. Can be rewinded.
+ *
+ */
+export declare class OINODbMemoryDataSet extends OINODbDataSet {
+    private _rows;
+    private _currentRow;
+    private _eof;
+    /**
+     * Constructor of `OINODbMemoryDataSet`.
+     *
+     * @param data data as OINODataRow[] (constructor will throw if invalid)
+     * @param errors error messages from SQL-query
+     *
+     */
+    constructor(data: unknown, errors?: string[]);
+    /**
+     * Is data set empty.
+     *
+     */
+    isEmpty(): boolean;
+    /**
+     * Is there no more content, i.e. either dataset is empty or we have moved beyond last line
+     *
+     */
+    isEof(): boolean;
+    /**
+     * Attempts to moves dataset to the next row, possibly waiting for more data to become available. Returns !isEof().
+     *
+     */
+    next(): Promise<boolean>;
+    /**
+     * Gets current row of data.
+     *
+     */
+    getRow(): OINODataRow;
+    /**
+     * Rewinds data set to the first row, returns !isEof().
+     *
+     */
+    first(): boolean;
+}

package/dist/types/OINODbFactory.d.ts

@@ -0,0 +1,35 @@
+import { OINODbApi, OINODbApiParams, OINODbParams, OINODb, OINODbConstructor, OINODbApiRequestParams } from "./index.js";
+/**
+ * Static factory class for easily creating things based on data
+ *
+ */
+export declare class OINODbFactory {
+    private static _dbRegistry;
+    /**
+     * Register a supported database class. Used to enable those that are installed in the factory
+     * instead of forcing everyone to install all database libraries.
+     *
+     * @param dbName name of the database implementation class
+     * @param dbTypeClass constructor for creating a database of that type
+     */
+    static registerDb(dbName: string, dbTypeClass: OINODbConstructor): void;
+    /**
+     * Create database from parameters from the registered classes.
+     *
+     * @param params database connection parameters
+     */
+    static createDb(params: OINODbParams): Promise<OINODb>;
+    /**
+     * Create API from parameters and calls initDatamodel on the datamodel.
+     *
+     * @param db databased used in API
+     * @param params parameters of the API
+     */
+    static createApi(db: OINODb, params: OINODbApiParams): Promise<OINODbApi>;
+    /**
+     * Creates a key-value-collection from Javascript URL parameters.
+     *
+     * @param request HTTP Request
+     */
+    static createParamsFromRequest(request: Request): OINODbApiRequestParams;
+}

package/dist/types/OINODbModelSet.d.ts

@@ -0,0 +1,51 @@
+import { OINODbDataSet, OINODbDataModel, OINOContentType, OINODataCell } from "./index.js";
+/**
+ * Class for dataset based on a data model that can be serialized to
+ * a supported format:
+ * - JSON (application/json)
+ * - CSV (text/csv)
+ *
+ */
+export declare class OINODbModelSet {
+    /** Reference to datamodel */
+    readonly datamodel: OINODbDataModel;
+    /** Reference to data set */
+    readonly dataset: OINODbDataSet;
+    /** Collection of errors */
+    errors: string[];
+    /**
+     * Constructor for `OINODbModelSet`.
+     *
+     * @param datamodel data model
+     * @param dataset data set
+     */
+    constructor(datamodel: OINODbDataModel, dataset: OINODbDataSet);
+    private _encodeAndHashFieldValue;
+    private _writeRowJson;
+    private _writeStringJson;
+    private _writeHeaderCsv;
+    private _writeRowCsv;
+    private _writeStringCsv;
+    private _writeRowFormdataParameterBlock;
+    private _writeRowFormdataFileBlock;
+    private _writeRowFormdata;
+    private _writeStringFormdata;
+    private _writeRowUrlencode;
+    private _writeStringUrlencode;
+    /**
+     * Serialize model set in the given format.
+     *
+     * @param [contentType=OINOContentType.json] serialization content type
+     *
+     */
+    writeString(contentType?: OINOContentType): Promise<string>;
+    /**
+     * Get value of given field in the current row. Undefined if no rows,
+     * field not found or value does not exist.
+     *
+     * @param fieldName name of the field
+     * @param serialize serialize the value
+     *
+     */
+    getValueByFieldName(fieldName: string, serialize?: boolean): OINODataCell;
+}

package/dist/types/OINODbParser.d.ts

@@ -0,0 +1,53 @@
+import { OINODbDataModel, OINODataRow, OINODbApiRequestParams } from "./index.js";
+/**
+ * Static factory class for easily creating things based on data
+ *
+ */
+export declare 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
+     *
+     */
+    static createRows(datamodel: OINODbDataModel, data: string | Buffer | object, requestParams: OINODbApiRequestParams): OINODataRow[];
+    /**
+      * Create data rows from request body based on the datamodel.
+      *
+      * @param datamodel datamodel of the api
+      * @param data data as a string
+      * @param requestParams parameters
+      *
+      */
+    static createRowsFromText(datamodel: OINODbDataModel, data: string, requestParams: OINODbApiRequestParams): OINODataRow[];
+    /**
+      * 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
+      *
+      */
+    static createRowsFromBlob(datamodel: OINODbDataModel, data: Buffer, requestParams: OINODbApiRequestParams): OINODataRow[];
+    /**
+     * Create one data row from javascript object based on the datamodel.
+     * NOTE! Data assumed to be unserialized i.e. of the native type (string, number, boolean, Buffer)
+     *
+     * @param datamodel datamodel of the api
+     * @param data data as javascript object
+     *
+     */
+    static createRowFromObject(datamodel: OINODbDataModel, data: any): OINODataRow;
+    private static _findCsvLineEnd;
+    private static _parseCsvLine;
+    private static _createRowFromCsv;
+    private static _createRowFromJsonObj;
+    private static _createRowFromJson;
+    private static _findMultipartBoundary;
+    private static _parseMultipartLine;
+    private static _multipartHeaderRegex;
+    private static _createRowFromFormdata;
+    private static _createRowFromUrlencoded;
+}

package/dist/types/OINODbRequestParams.d.ts

@@ -0,0 +1,146 @@
+import { OINODbDataModel } from "./index.js";
+/**
+ * Supported logical conjunctions in filter predicates.
+ * @enum
+ */
+export declare enum OINODbSqlBooleanOperation {
+    and = "and",
+    or = "or",
+    not = "not"
+}
+/**
+ * Supported logical conjunctions in filter predicates.
+ * @enum
+ */
+export declare enum OINODbSqlComparison {
+    lt = "lt",
+    le = "le",
+    eq = "eq",
+    ge = "ge",
+    gt = "gt",
+    like = "like"
+}
+/**
+ * Class for recursively parsing of filters and printing them as SQL conditions.
+ * Supports three types of statements
+ * - comparison: (field)-lt|le|eq|ge|gt|like(value)
+ * - negation: -not(filter)
+ * - conjunction/disjunction: (filter)-and|or(filter)
+ * Supported conditions are comparisons (<, <=, =, >=, >) and substring match (LIKE).
+ *
+ */
+export declare class OINODbSqlFilter {
+    private static _booleanOperationRegex;
+    private static _negationRegex;
+    private static _filterComparisonRegex;
+    private _leftSide;
+    private _rightSide;
+    private _operator;
+    /**
+     * Constructor of `OINODbSqlFilter`
+     * @param leftSide left side of the filter, either another filter or a column name
+     * @param operation operation of the filter, either `OINODbSqlComparison` or `OINODbSqlBooleanOperation`
+     * @param rightSide right side of the filter, either another filter or a value
+     */
+    constructor(leftSide: OINODbSqlFilter | string, operation: OINODbSqlComparison | OINODbSqlBooleanOperation | null, rightSide: OINODbSqlFilter | string);
+    /**
+     * Constructor for `OINOFilter` as parser of http parameter.
+     *
+     * @param filterString string representation of filter from HTTP-request
+     *
+     */
+    static parse(filterString: string): OINODbSqlFilter;
+    /**
+     * Construct a new `OINOFilter` as combination of (boolean and/or) of two filters.
+     *
+     * @param leftSide left side to combine
+     * @param operation boolean operation to use in combination
+     * @param rightSide right side to combine
+     *
+     */
+    static combine(leftSide: OINODbSqlFilter | undefined, operation: OINODbSqlBooleanOperation, rightSide: OINODbSqlFilter | undefined): OINODbSqlFilter | undefined;
+    private _operatorToSql;
+    /**
+     * Does filter contain any valid conditions.
+     *
+     */
+    isEmpty(): boolean;
+    /**
+     * Print filter as SQL condition based on the datamodel of the API.
+     *
+     * @param dataModel data model (and database) to use for formatting of values
+     *
+     */
+    toSql(dataModel: OINODbDataModel): string;
+}
+/**
+ * Class for ordering select results on a number of columns.
+ *
+ */
+export declare class OINODbSqlOrder {
+    private static _orderColumnRegex;
+    private _columns;
+    private _descending;
+    /**
+     * Constructor for `OINODbSqlOrder`.
+     *
+     * @param column_or_array single or array of columns to order on
+     * @param descending_or_array single or array of booleans if ordes is descending
+     *
+     */
+    constructor(column_or_array: string[] | string, descending_or_array: boolean[] | boolean);
+    /**
+     * Constructor for `OINODbSqlOrder` as parser of http parameter.
+     *
+     * @param orderString string representation of ordering from HTTP-request
+     *
+     */
+    static parse(orderString: string): OINODbSqlOrder;
+    /**
+     * Does filter contain any valid conditions.
+     *
+     */
+    isEmpty(): boolean;
+    /**
+     * Print order as SQL condition based on the datamodel of the API.
+     *
+     * @param dataModel data model (and database) to use for formatting of values
+     *
+     */
+    toSql(dataModel: OINODbDataModel): string;
+}
+/**
+ * Class for limiting the number of results.
+ *
+ */
+export declare class OINODbSqlLimit {
+    private static _limitRegex;
+    private _limit;
+    private _page;
+    /**
+     * Constructor for `OINODbSqlLimit`.
+     *
+     * @param limit maximum number of items to return
+     *
+     */
+    constructor(limit: number, page?: number);
+    /**
+     * Constructor for `OINODbSqlLimit` as parser of http parameter.
+     *
+     * @param limitString string representation of limit from HTTP-request
+     *
+     */
+    static parse(limitString: string): OINODbSqlLimit;
+    /**
+     * Does filter contain any valid conditions.
+     *
+     */
+    isEmpty(): boolean;
+    /**
+     * Print order as SQL condition based on the datamodel of the API.
+     *
+     * @param dataModel data model (and database) to use for formatting of values
+     *
+     */
+    toSql(dataModel: OINODbDataModel): string;
+}

package/dist/types/OINODbSqlParams.d.ts

@@ -0,0 +1,147 @@
+import { OINODbDataModel } from "./index.js";
+/**
+ * Supported logical conjunctions in filter predicates.
+ * @enum
+ */
+export declare enum OINODbSqlBooleanOperation {
+    and = "and",
+    or = "or",
+    not = "not"
+}
+/**
+ * Supported logical conjunctions in filter predicates.
+ * @enum
+ */
+export declare enum OINODbSqlComparison {
+    lt = "lt",
+    le = "le",
+    eq = "eq",
+    ge = "ge",
+    gt = "gt",
+    like = "like"
+}
+/**
+ * Class for recursively parsing of filters and printing them as SQL conditions.
+ * Supports three types of statements
+ * - comparison: (field)-lt|le|eq|ge|gt|like(value)
+ * - negation: -not(filter)
+ * - conjunction/disjunction: (filter)-and|or(filter)
+ * Supported conditions are comparisons (<, <=, =, >=, >) and substring match (LIKE).
+ *
+ */
+export declare class OINODbSqlFilter {
+    private static _booleanOperationRegex;
+    private static _negationRegex;
+    private static _filterComparisonRegex;
+    private _leftSide;
+    private _rightSide;
+    private _operator;
+    /**
+     * Constructor of `OINODbSqlFilter`
+     * @param leftSide left side of the filter, either another filter or a column name
+     * @param operation operation of the filter, either `OINODbSqlComparison` or `OINODbSqlBooleanOperation`
+     * @param rightSide right side of the filter, either another filter or a value
+     */
+    constructor(leftSide: OINODbSqlFilter | string, operation: OINODbSqlComparison | OINODbSqlBooleanOperation | null, rightSide: OINODbSqlFilter | string);
+    /**
+     * Constructor for `OINOFilter` as parser of http parameter.
+     *
+     * @param filterString string representation of filter from HTTP-request
+     *
+     */
+    static parse(filterString: string): OINODbSqlFilter;
+    /**
+     * Construct a new `OINOFilter` as combination of (boolean and/or) of two filters.
+     *
+     * @param leftSide left side to combine
+     * @param operation boolean operation to use in combination
+     * @param rightSide right side to combine
+     *
+     */
+    static combine(leftSide: OINODbSqlFilter | undefined, operation: OINODbSqlBooleanOperation, rightSide: OINODbSqlFilter | undefined): OINODbSqlFilter | undefined;
+    private _operatorToSql;
+    /**
+     * Does filter contain any valid conditions.
+     *
+     */
+    isEmpty(): boolean;
+    /**
+     * Print filter as SQL condition based on the datamodel of the API.
+     *
+     * @param dataModel data model (and database) to use for formatting of values
+     *
+     */
+    toSql(dataModel: OINODbDataModel): string;
+}
+/**
+ * Class for ordering select results on a number of columns.
+ *
+ */
+export declare class OINODbSqlOrder {
+    private static _orderColumnRegex;
+    private _columns;
+    private _descending;
+    /**
+     * Constructor for `OINODbSqlOrder`.
+     *
+     * @param column_or_array single or array of columns to order on
+     * @param descending_or_array single or array of booleans if ordes is descending
+     *
+     */
+    constructor(column_or_array: string[] | string, descending_or_array: boolean[] | boolean);
+    /**
+     * Constructor for `OINODbSqlOrder` as parser of http parameter.
+     *
+     * @param orderString string representation of ordering from HTTP-request
+     *
+     */
+    static parse(orderString: string): OINODbSqlOrder;
+    /**
+     * Does filter contain any valid conditions.
+     *
+     */
+    isEmpty(): boolean;
+    /**
+     * Print order as SQL condition based on the datamodel of the API.
+     *
+     * @param dataModel data model (and database) to use for formatting of values
+     *
+     */
+    toSql(dataModel: OINODbDataModel): string;
+}
+/**
+ * Class for limiting the number of results.
+ *
+ */
+export declare class OINODbSqlLimit {
+    private static _limitRegex;
+    private _limit;
+    private _page;
+    /**
+     * Constructor for `OINODbSqlLimit`.
+     *
+     * @param limit maximum number of items to return
+     * @param page page number to return starting from 1
+     *
+     */
+    constructor(limit: number, page?: number);
+    /**
+     * Constructor for `OINODbSqlLimit` as parser of http parameter.
+     *
+     * @param limitString string representation of limit from HTTP-request
+     *
+     */
+    static parse(limitString: string): OINODbSqlLimit;
+    /**
+     * Does filter contain any valid conditions.
+     *
+     */
+    isEmpty(): boolean;
+    /**
+     * Print order as SQL condition based on the datamodel of the API.
+     *
+     * @param dataModel data model (and database) to use for formatting of values
+     *
+     */
+    toSql(dataModel: OINODbDataModel): string;
+}

package/dist/types/OINODbSwagger.d.ts

@@ -0,0 +1,25 @@
+import { OINODbApi } from "./index.js";
+/**
+ * Static class for Swagger utilities
+ *
+ */
+export declare class OINODbSwagger {
+    private static _getSchemaApiMethodParamsQueryId;
+    private static _getSchemaApiMethodParamsBody;
+    private static _getSchemaApiMethodDescription;
+    private static _getSchemaApiMethodOperationId;
+    private static _getSchemaOinoResponse;
+    private static _getSchemaFieldType;
+    private static _getSwaggerApiType;
+    private static _getSchemaType;
+    private static _getSchemaApiMethodParams;
+    private static _getSchemaApiMethod;
+    private static _getSwaggerApiPath;
+    /**
+     * Returns swagger.json as object of the given API's.
+     *
+     * @param apis array of API's use for Swagger definition
+     *
+     */
+    static getApiDefinition(apis: OINODbApi[]): any;
+}

package/dist/types/index.d.ts

@@ -0,0 +1,111 @@
+import { OINOContentType } from "@oino-ts/common";
+export { OINOContentType };
+export { OINO_ERROR_PREFIX, OINO_WARNING_PREFIX, OINO_INFO_PREFIX, OINO_DEBUG_PREFIX, OINOStr, OINOBenchmark, OINOLog, OINOLogLevel, OINOConsoleLog, OINOResult, OINOHttpResult, OINOHtmlTemplate } from "@oino-ts/common";
+import { OINODb } from "./OINODb.js";
+import { OINODbDataField } from "./OINODbDataField.js";
+import { OINODbSqlFilter, OINODbSqlLimit, OINODbSqlOrder } from "./OINODbSqlParams.js";
+export { OINODbApiResult, OINODbHtmlTemplate, OINODbApi } from "./OINODbApi.js";
+export { OINODbDataModel } from "./OINODbDataModel.js";
+export { OINODbModelSet } from "./OINODbModelSet.js";
+export { OINODbDataField, OINOBooleanDataField, OINONumberDataField, OINOStringDataField, OINOBlobDataField, OINODatetimeDataField } from "./OINODbDataField.js";
+export { OINODbDataSet, OINODbMemoryDataSet, OINODb } from "./OINODb.js";
+export { OINODbSqlFilter, OINODbSqlOrder, OINODbSqlComparison, OINODbSqlLimit, OINODbSqlBooleanOperation } from "./OINODbSqlParams.js";
+export { OINODbConfig } from "./OINODbConfig.js";
+export { OINODbFactory } from "./OINODbFactory.js";
+export { OINODbSwagger } from "./OINODbSwagger.js";
+export { OINODbParser } from "./OINODbParser.js";
+/** API parameters */
+export type OINODbApiParams = {
+    /** Name of the database table */
+    tableName: string;
+    /** Reject values that exceed field max length (behaviour on such is platform dependent) */
+    failOnOversizedValues?: Boolean;
+    /** Reject PUT-requests that contain values for autoinc-type fields */
+    failOnUpdateOnAutoinc?: boolean;
+    /** Reject POST-requests without primary key value (can work if DB-side ) */
+    failOnInsertWithoutKey?: boolean;
+    /** Treat date type fields as just strings and use the native formatting instead of the ISO 8601 format */
+    useDatesAsString?: Boolean;
+    /** Exclude all fields with this prefix from the API */
+    excludeFieldPrefix?: string;
+    /** Exclude given fields from the API */
+    excludeFields?: string[];
+    /** Enable hashids for numeric primarykeys by adding a 32 char key */
+    hashidKey?: string;
+    /** Set (minimum) length (12-32 chars) of the hashids */
+    hashidLength?: number;
+    /** Make hashids static per row/table */
+    hashidStaticIds?: boolean;
+    /** Name of field that has the modified field */
+    cacheModifiedField?: string;
+};
+/**
+ * Database class (constructor) type
+ * @param dbParams database parameters
+ */
+export type OINODbConstructor = new (dbParams: OINODbParams) => OINODb;
+/** Database parameters */
+export type OINODbParams = {
+    /** Name of the database class (e.g. OINODbPostgresql)  */
+    type: string;
+    /** Connection URL, either file://-path or an IP-address or an HTTP-url */
+    url: string;
+    /** Name of the database */
+    database: string;
+    /** TCP port of the database */
+    port?: number;
+    /** Username used to authenticate */
+    user?: string;
+    /** Password used to authenticate */
+    password?: string;
+};
+/** Field parameters in database */
+export type OINODbDataFieldParams = {
+    /** Is the field a primary key */
+    isPrimaryKey: Boolean;
+    /** Is the field a primary key */
+    isForeignKey: Boolean;
+    /** Is the field an auto inc type */
+    isAutoInc: Boolean;
+    /** Is the field allowed to have null values */
+    isNotNull: Boolean;
+};
+/**
+ * Callback to filter data fields
+ * @param field fields to filter
+ */
+export type OINODbDataFieldFilter = (field: OINODbDataField) => Boolean;
+/** Request options */
+export type OINODbSqlParams = {
+    /** Additional SQL select where-conditions */
+    filter?: OINODbSqlFilter;
+    /** SQL result ordering conditions */
+    order?: OINODbSqlOrder;
+    /** SQL result limit condition */
+    limit?: OINODbSqlLimit;
+};
+/** Request options */
+export type OINODbApiRequestParams = {
+    /** Content type of the request body */
+    requestType?: OINOContentType;
+    /** Content type of the response body */
+    responseType?: OINOContentType;
+    /** Multipart boundary token */
+    multipartBoundary?: string;
+    /** Request last-modified value */
+    lastModified?: number;
+    /** Request etag values */
+    etags?: string[];
+    /** SQL parameters */
+    sqlParams?: OINODbSqlParams;
+};
+/** A single column value of a data row */
+export type OINODataCell = string | bigint | number | boolean | Date | Uint8Array | Buffer | null | undefined;
+/** A single data row */
+export type OINODataRow = Array<OINODataCell>;
+/** Empty row instance */
+export declare const OINODB_EMPTY_ROW: OINODataRow;
+/** Empty row array instance */
+export declare const OINODB_EMPTY_ROWS: OINODataRow[];
+/** Key-value collection */
+export type OINOValues = Record<string, string>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oino-ts/db",
-  "version": "0.1.2",
+  "version": "0.2.0",
   "description": "OINO TS library package for publishing an SQL database tables as a REST API.",
   "author": "Matias Kiviniemi (pragmatta)",
   "license": "MPL-2.0",
@@ -19,12 +19,12 @@
   "module": "./dist/esm/index.js",
   "types": "./dist/types/index.d.ts",
   "dependencies": {
-    "@oino-ts/common": "0.1.2"
+    "@oino-ts/common": "0.2.0"
   },
   "devDependencies": {
     "@types/node": "^20.14.10",
     "@types/bun": "^1.1.14",
-    "@oino-ts/types": "0.1.2",
+    "@oino-ts/types": "0.2.0",
     "typedoc": "^0.25.13"
   },
   "files": [

package/src/OINODbApi.test.ts

@@ -39,7 +39,7 @@ const api_tests:OINOTestParams[] = [
         name: "API",
         apiParams: { tableName: "Orders" },
         requestParams: {
-            sqlParams: { filter: OINODbSqlFilter.parse("(ShipPostalCode)-like(0502%)"), order: OINODbSqlOrder.parse("ShipPostalCode desc,Freight asc"), limit: OINODbSqlLimit.parse("5 page 2") }
+            sqlParams: { filter: OINODbSqlFilter.parse("(ShipPostalCode)-like(0502%)"), order: OINODbSqlOrder.parse("ShipPostalCode-,Freight+"), limit: OINODbSqlLimit.parse("5 page 2") }
         },
         postRow: [30000,"CACTU",1,new Date("2024-04-05"),new Date("2024-04-06"),new Date("2024-04-07"),2,"184.75","a'b\"c%d_e\tf\rg\nh\\i","Garden House Crowther Way","Cowes","British Isles","PO31 7PJ","UK"],
         putRow: [30000,"CACTU",1,new Date("2023-04-05"),new Date("2023-04-06"),new Date("2023-04-07"),2,"847.51","k'l\"m%n_o\tp\rq\nr\\s","59 rue de l'Abbaye","Cowes2","Western Europe","PO31 8PJ","UK"]
@@ -48,7 +48,7 @@ const api_tests:OINOTestParams[] = [
         name: "API",
         apiParams: { tableName: "Products", failOnOversizedValues: true },
         requestParams: {
-            sqlParams: { filter: OINODbSqlFilter.parse("(UnitsInStock)-le(5)"), order: OINODbSqlOrder.parse("UnitsInStock asc,UnitPrice asc"), limit: OINODbSqlLimit.parse("7") }
+            sqlParams: { filter: OINODbSqlFilter.parse("(UnitsInStock)-le(5)"), order: OINODbSqlOrder.parse("UnitsInStock,UnitPrice"), limit: OINODbSqlLimit.parse("7") }
         },
         postRow: [99, "Umeshu", 1, 1, "500 ml", 12.99, 2, 0, 20, 0],
         putRow: [99, "Umeshu", 1, 1, undefined, 24.99, 3, 0, 20, 0]

package/src/OINODbSqlParams.ts

@@ -181,7 +181,7 @@ export class OINODbSqlFilter {
  *
  */
 export class OINODbSqlOrder {
-    private static _orderColumnRegex = /^\s*(\w+)\s?(ASC|DESC)?\s*?$/i
+    private static _orderColumnRegex = /^\s*(\w+)\s?(ASC|DESC|\+|\-)?\s*?$/i
     
     private _columns: string[]
     private _descending: boolean[]
@@ -223,7 +223,8 @@ export class OINODbSqlOrder {
             let match = OINODbSqlOrder._orderColumnRegex.exec(column_strings[i])
             if (match != null) {
                 columns.push(match[1])
-                directions.push((match[2] || "DESC").toUpperCase() == "DESC")
+                const dir:string = (match[2] || "ASC").toUpperCase() 
+                directions.push((dir == "DESC") || (dir == "-"))
             }
         }
         return new OINODbSqlOrder(columns, directions)