@oino-ts/db 0.21.2 → 1.0.1

package/dist/types/OINODb.d.ts

@@ -1,12 +1,12 @@
-import { OINOResult } from "@oino-ts/common";
-import { OINODbParams, OINODbApi, OINODataCell, OINODataRow } from "./index.js";
+import { OINODataSet, OINODataSource } from "@oino-ts/common";
+import { OINODbParams } from "./OINODbConstants.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;
+export declare abstract class OINODb extends OINODataSource {
+    protected readonly dbParams: OINODbParams;
     /** Name of the database */
     readonly name: string;
     isConnected: boolean;
@@ -16,82 +16,20 @@ export declare abstract class OINODb {
      * @param params database parameters
      */
     constructor(params: OINODbParams);
-    /**
-     * Connect to database.
-     *
-     */
-    abstract connect(): Promise<OINOResult>;
-    /**
-     * Validate connection to database is working.
-     *
-     */
-    abstract validate(): Promise<OINOResult>;
-    /**
-     * Disconnect from database.
-     *
-     */
-    abstract disconnect(): Promise<void>;
-    /**
-     * 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;
-    /**
-     * Print a single string value as valid sql literal
-     *
-     * @param sqlString string value
-     *
-     */
-    abstract printSqlString(sqlString: 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>;
+    abstract sqlSelect(sql: string): Promise<OINODataSet>;
     /**
      * 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>;
+    abstract sqlExec(sql: string): Promise<OINODataSet>;
     /**
      * Print SQL select statement with DB specific formatting.
      *
@@ -115,108 +53,3 @@ export declare abstract class OINODb {
      */
     printSqlInsert(tableName: string, columns: string, values: string, returnIdFields?: 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 extends OINOResult {
-    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;
-    /**
-     * Gets all rows of data.
-     *
-     * NOTE: This is left abstract instead of just using `getRow()` so that DB implementations can hopefully optimize not duplicating data     *
-     */
-    abstract getAllRows(): Promise<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;
-    /**
-     * Gets all rows of data.
-     *
-     */
-    getAllRows(): Promise<OINODataRow[]>;
-    /**
-     * Rewinds data set to the first row, returns !isEof().
-     *
-     */
-    first(): boolean;
-}

package/dist/types/OINODbApi.d.ts

@@ -1,98 +1,17 @@
-/// <reference types="node" />
-/// <reference types="node" />
-import { Buffer } from "node:buffer";
-import { OINOResult, OINOHttpRequest, type OINOHttpRequestInit, OINOHttpResult, OINOHtmlTemplate, OINOContentType } from "@oino-ts/common";
-import { OINODbApiParams, OINODb, OINODbDataModel, OINODataRow, OINODbModelSet, OINODbSqlParams, OINODbSqlAggregate, OINODbSqlSelect, OINODbSqlFilter, OINODbSqlOrder, OINODbSqlLimit } from "./index.js";
-import { OINOHashid } from "@oino-ts/hashid";
-export type OINODbApiData = string | OINODataRow[] | Buffer | Uint8Array | object | null;
-export interface OINODbApiRequestInit extends OINOHttpRequestInit {
-    rowId?: string;
-    rowData?: OINODbApiData;
-    sqlParams?: OINODbSqlParams;
-    filter?: OINODbSqlFilter | string;
-    order?: OINODbSqlOrder | string;
-    limit?: OINODbSqlLimit | string;
-    aggregate?: OINODbSqlAggregate | string;
-    select?: OINODbSqlSelect | string;
-}
-export declare class OINODbApiRequest extends OINOHttpRequest {
-    rowId: string;
-    rowData: OINODbApiData;
-    sqlParams: OINODbSqlParams;
-    constructor(init: OINODbApiRequestInit);
-    static fromFetchRequest(request: Request, rowId?: string, rowData?: OINODbApiData, sqlParams?: OINODbSqlParams): Promise<OINODbApiRequest>;
-    static fromHttpRequest(request: OINOHttpRequest, rowId?: string, rowData?: OINODbApiData, sqlParams?: OINODbSqlParams): OINODbApiRequest;
-}
-/**
- * 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 */
-    request: OINODbApiRequest;
-    /** Returned data if any */
-    data?: OINODbModelSet;
-    /**
-     * Constructor of OINODbApiResult.
-     *
-     * @param request DbApi request parameters
-     * @param data result data
-     *
-     */
-    constructor(request: OINODbApiRequest, data?: OINODbModelSet);
-    /**
-     * Creates a HTTP Response from API results.
-     *
-     * @param headers Headers to include in the response
-     *
-     */
-    writeApiResponse(headers?: Record<string, string>): Promise<Response>;
-}
-/**
- * Specialized HTML template that can render ´OINODbApiResult´.
- *
- */
-export declare class OINODbHtmlTemplate extends OINOHtmlTemplate {
-    /** Locale validation regex */
-    static LOCALE_REGEX: RegExp;
-    /** Locale formatter */
-    protected _locale: Intl.DateTimeFormat | null;
-    protected _numberDecimals: number;
-    /**
-     * Constructor of OINODbHtmlTemplate.
-     *
-     * @param template HTML template string
-     * @param numberDecimals Number of decimals to use for numbers, -1 for no formatting
-     * @param dateLocaleStr Datetime format string, either "iso" for ISO8601 or "default" for system default or valid locale string
-     * @param dateLocaleStyle Datetime format style, either "short/medium/long/full" or Intl.DateTimeFormat options
-     *
-     */
-    constructor(template: string, numberDecimals?: number, dateLocaleStr?: string, dateLocaleStyle?: string | any);
-    /**
-     * 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>;
-}
+import { OINOApi, OINOApiParams, OINOHttpRequest, OINOApiRequest, OINOApiResult, OINOContentType, OINOQueryParams, OINOApiData } from "@oino-ts/common";
+import { OINODb } from "./OINODb.js";
+import { OINODbDataModel } from "./OINODbDataModel.js";
 /**
  * API class with method to process HTTP REST requests.
  *
  */
-export declare class OINODbApi {
-    /** Enable debug output on errors */
-    private _debugOnError;
-    /** API database reference */
+export declare class OINODbApi extends OINOApi {
+    /** DB reference */
     readonly db: OINODb;
-    /** API datamodel */
-    readonly datamodel: OINODbDataModel;
-    /** API parameters */
-    readonly params: OINODbApiParams;
-    /** API hashid */
-    readonly hashid: OINOHashid | null;
+    /** DB parameters reference */
+    readonly dbParams: OINOApiParams;
+    /** DB datamodel reference */
+    dbDatamodel: OINODbDataModel | null;
     /**
      * Constructor of API object.
      * NOTE! OINODb.initDatamodel must be called if created manually instead of the factory.
@@ -101,19 +20,14 @@ export declare class OINODbApi {
      * @param params parameters for the API
      *
      */
-    constructor(db: OINODb, params: OINODbApiParams);
+    constructor(db: OINODb, params: OINOApiParams);
+    initializeDatamodel(datamodel: OINODbDataModel): void;
     private _validateRow;
     private _parseData;
     private _doGet;
     private _doPost;
     private _doPut;
     private _doDelete;
-    /**
-     * Enable or disable debug output on errors.
-     *
-     * @param debugOnError true to enable debug output on errors, false to disable
-     */
-    setDebugOnError(debugOnError: boolean): void;
     /**
      * Method for handling a HTTP REST request with GET, POST, PUT, DELETE corresponding to
      * SQL select, insert, update and delete.
@@ -121,10 +35,10 @@ export declare class OINODbApi {
      * @param request OINO HTTP request object containing all parameters of the REST request
      * @param rowId URL id of the REST request
      * @param rowData HTTP body data as either serialized string or unserialized JS object or OINODataRow-array or Buffer/Uint8Array binary data
-     * @param sqlParams SQL parameters for the REST request
+     * @param queryParams SQL parameters for the REST request
      *
      */
-    doHttpRequest(request: OINOHttpRequest, rowId: string, rowData: OINODbApiData, sqlParams: OINODbSqlParams): Promise<OINODbApiResult>;
+    doHttpRequest(request: OINOHttpRequest, rowId: string, rowData: OINOApiData, queryParams: OINOQueryParams): Promise<OINOApiResult>;
     /**
      * Method for handling a HTTP REST request with GET, POST, PUT, DELETE corresponding to
      * SQL select, insert, update and delete.
@@ -132,12 +46,12 @@ export declare class OINODbApi {
      * @param method HTTP method of the REST request
      * @param rowId URL id of the REST request
      * @param rowData HTTP body data as either serialized string or unserialized JS object or OINODataRow-array or Buffer/Uint8Array binary data
-     * @param sqlParams SQL parameters for the REST request
+     * @param queryParams SQL parameters for the REST request
      * @param contentType content type of the HTTP body data, default is JSON
      *
      */
-    doRequest(method: string, rowId: string, rowData: OINODbApiData, sqlParams: OINODbSqlParams, contentType?: OINOContentType): Promise<OINODbApiResult>;
-    doApiRequest(request: OINODbApiRequest): Promise<OINODbApiResult>;
+    doRequest(method: string, rowId: string, rowData: OINOApiData, queryParams: OINOQueryParams, contentType?: OINOContentType): Promise<OINOApiResult>;
+    doApiRequest(request: OINOApiRequest): Promise<OINOApiResult>;
     /**
      * Method for handling a HTTP REST request with batch update using PUT or DELETE methods.
      *
@@ -146,14 +60,14 @@ export declare class OINODbApi {
      * @param rowData HTTP body data as either serialized string or unserialized JS object or OINODataRow-array or Buffer/Uint8Array binary data
      *
      */
-    doBatchUpdate(method: string, rowId: string, rowData: OINODbApiData, sqlParams?: OINODbSqlParams): Promise<OINODbApiResult>;
+    doBatchUpdate(method: string, rowId: string, rowData: OINOApiData, queryParams?: OINOQueryParams): Promise<OINOApiResult>;
     /**
      * Method for handling a HTTP REST request with batch update using PUT or DELETE methods.
      *
      * @param request HTTP URL parameters as key-value-pairs
      *
      */
-    runBatchUpdate(request: OINODbApiRequest): Promise<OINODbApiResult>;
+    doBatchApiRequest(request: OINOApiRequest): Promise<OINOApiResult>;
     /**
      * Method to check if a field is included in the API params.
      *

package/dist/types/OINODbConstants.d.ts

@@ -0,0 +1,23 @@
+import { OINODb } from "./OINODb.js";
+/**
+ * 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;
+};
+/** Constant for undefined values */
+export declare const OINODB_UNDEFINED = "";

package/dist/types/OINODbDataModel.d.ts

@@ -1,14 +1,14 @@
-import { OINODbDataField, OINODbApi, OINODataRow, OINODbDataFieldFilter, OINODbSqlParams } from "./index.js";
+import { OINODataModel, OINODataField, OINODataRow, OINOQueryParams } from "@oino-ts/common";
+import { OINODbApi } from "./OINODbApi.js";
 /**
  * OINO Datamodel object for representing one database table and it's columns.
  *
  */
-export declare class OINODbDataModel {
-    private _fieldIndexLookup;
+export declare class OINODbDataModel extends OINODataModel {
     /** Database refererence of the table */
-    readonly api: OINODbApi;
+    readonly dbApi: OINODbApi;
     /** Field refererences of the API */
-    readonly fields: OINODbDataField[];
+    readonly fields: OINODataField[];
     /**
      * Constructor of the data model.
      * NOTE! OINODbDataModel.initialize must be called after constructor to populate fields.
@@ -17,65 +17,11 @@ export declare class OINODbDataModel {
      *
      */
     constructor(api: OINODbApi);
-    /**
-     * Initialize datamodel from SQL schema.
-     *
-     */
-    initialize(): Promise<void>;
-    private _printSqlColumnNames;
+    private _printColumnNames;
     private _printSqlInsertColumnsAndValues;
     private _printSqlUpdateValues;
     private _printSqlPrimaryKeyCondition;
     private _printSqlPrimaryKeyColumns;
-    /**
-     * 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.
      *
@@ -83,7 +29,7 @@ export declare class OINODbDataModel {
      * @param params OINO reqest params
      *
      */
-    printSqlSelect(id: string, params: OINODbSqlParams): string;
+    printSqlSelect(id: string, params: OINOQueryParams): string;
     /**
      * Print SQL insert statement from one data row.
      *

package/dist/types/OINODbFactory.d.ts

@@ -1,4 +1,7 @@
-import { OINODbApi, OINODbApiParams, OINODbParams, OINODb, OINODbConstructor } from "./index.js";
+import { OINOApiParams } from "@oino-ts/common";
+import { OINODbParams, OINODbConstructor } from "./OINODbConstants.js";
+import { OINODbApi } from "./OINODbApi.js";
+import { OINODb } from "./OINODb.js";
 /**
  * Static factory class for easily creating things based on data
  *
@@ -27,5 +30,5 @@ export declare class OINODbFactory {
      * @param db databased used in API
      * @param params parameters of the API
      */
-    static createApi(db: OINODb, params: OINODbApiParams): Promise<OINODbApi>;
+    static createApi(db: OINODb, params: OINOApiParams): Promise<OINODbApi>;
 }

package/dist/types/OINODbQueryParams.d.ts

@@ -0,0 +1,72 @@
+import { OINOQueryFilter, OINOQueryOrder, OINOQueryLimit, OINOQueryAggregate, OINOQuerySelect, OINODataModel } from "@oino-ts/common";
+import { OINODbDataModel } from "./OINODbDataModel.js";
+/**
+ * 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 OINODbQueryFilter extends OINOQueryFilter {
+    private static operatorToSql;
+    /**
+     * Print filter as SQL condition based on the datamodel of the API.
+     *
+     * @param dataModel data model (and database) to use for formatting of values
+     *
+     */
+    static printSql(filter: OINOQueryFilter, dataModel: OINODbDataModel): string;
+}
+/**
+ * Class for ordering select results on a number of columns.
+ *
+ */
+export declare class OINODbQueryOrder extends OINOQueryOrder {
+    /**
+     * Print order as SQL condition based on the datamodel of the API.
+     *
+     * @param order order instance
+     * @param dataModel data model (and database) to use for formatting of values
+     *
+     */
+    static printSql(order: OINOQueryOrder, dataModel: OINODbDataModel): string;
+}
+/**
+ * Class for limiting the number of results.
+ *
+ */
+export declare class OINODbQueryLimit extends OINOQueryLimit {
+    /**
+     * Print order as SQL condition based on the datamodel of the API.
+     *
+     * @param limit limit instance
+     * @param dataModel data model (and database) to use for formatting of values
+     *
+     */
+    static printSql(limit: OINOQueryLimit, dataModel: OINODbDataModel): string;
+}
+/**
+ * Class for limiting the number of results.
+ *
+ */
+export declare class OINODbQueryAggregate extends OINOQueryAggregate {
+    /**
+     * Print non-aggregated fields as SQL GROUP BY-condition based on the datamodel of the API.
+     *
+     * @param aggregate aggregate instance
+     * @param dataModel data model (and database) to use for formatting of values
+     * @param select what fields to select
+     *
+     */
+    static printSql(aggregate: OINOQueryAggregate, dataModel: OINODataModel, select?: OINOQuerySelect): string;
+    /**
+     * Print non-aggregated fields as SQL GROUP BY-condition based on the datamodel of the API.
+     *
+     * @param dataModel data model (and database) to use for formatting of values
+     * @param select what fields to select
+     *
+     */
+    static printColumnNames(aggregate: OINOQueryAggregate, dataModel: OINODataModel, select?: OINOQuerySelect): string;
+}