@oino-ts/types 0.21.2 → 1.0.0

package/common/src/OINOQueryParams.d.ts

@@ -0,0 +1,270 @@
+/**
+ * Supported logical conjunctions in filter predicates.
+ * @enum
+ */
+export declare enum OINOQueryBooleanOperation {
+    and = "and",
+    or = "or",
+    not = "not"
+}
+/**
+ * Supported logical conjunctions in filter predicates.
+ * @enum
+ */
+export declare enum OINOQueryComparison {
+    lt = "lt",
+    le = "le",
+    eq = "eq",
+    ne = "ne",
+    ge = "ge",
+    gt = "gt",
+    like = "like"
+}
+/**
+ * Supported logical conjunctions in filter predicates.
+ * @enum
+ */
+export declare enum OINOQueryNullCheck {
+    isnull = "isnull",
+    isNotNull = "isNotNull"
+}
+/**
+ * Supported aggregation functions in OINODbQueryAggregate.
+ * @enum
+ */
+export declare enum OINOQueryAggregateFunctions {
+    count = "count",
+    sum = "sum",
+    avg = "avg",
+    min = "min",
+    max = "max"
+}
+/**
+ * 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 OINOQueryFilter {
+    protected static _booleanOperationRegex: RegExp;
+    protected static _negationRegex: RegExp;
+    protected static _filterComparisonRegex: RegExp;
+    protected static _filterNullCheckRegex: RegExp;
+    readonly leftSide: OINOQueryFilter | string;
+    readonly rightSide: OINOQueryFilter | string;
+    readonly operator: OINOQueryComparison | OINOQueryBooleanOperation | OINOQueryNullCheck | null;
+    /**
+     * Constructor of `OINOQueryFilter`
+     * @param leftSide left side of the filter, either another filter or a column name
+     * @param operation operation of the filter, either `OINOQueryComparison` or `OINOQueryBooleanOperation`
+     * @param rightSide right side of the filter, either another filter or a value
+     */
+    constructor(leftSide: OINOQueryFilter | string, operation: OINOQueryComparison | OINOQueryBooleanOperation | OINOQueryNullCheck | null, rightSide: OINOQueryFilter | string);
+    /**
+     * Constructor for `OINOQueryFilter` as parser of http parameter.
+     *
+     * Supports three types of statements:
+     * - comparison: (field)-lt|le|eq|ge|gt|like(value)
+     * - negation: -not(filter)
+     * - conjunction/disjunction: (filter)-and|or(filter)
+     * - null check: -isnull(field) or -isNotNull(field)
+     *
+     * @param filterString string representation of filter from HTTP-request
+     *
+     */
+    static parse(filterString: string): OINOQueryFilter;
+    /**
+     * Construct a new `OINOQueryFilter` 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: OINOQueryFilter | undefined, operation: OINOQueryBooleanOperation, rightSide: OINOQueryFilter | undefined): OINOQueryFilter | undefined;
+    /**
+     * Combine two filters with an AND operation.
+     *
+     * @param leftSide left side filter
+     * @param rightSide right side filter
+     *
+     */
+    static and(leftSide: OINOQueryFilter, rightSide: OINOQueryFilter): OINOQueryFilter | undefined;
+    /**
+     * Combine two filters with an OR operation.
+     *
+     * @param leftSide left side filter
+     * @param rightSide right side filter
+     *
+     */
+    static or(leftSide: OINOQueryFilter, rightSide: OINOQueryFilter): OINOQueryFilter | undefined;
+    /**
+     * Negate a filter with a NOT operation.
+     *
+     * @param leftSide left side filter
+     *
+     */
+    static not(leftSide: OINOQueryFilter): OINOQueryFilter | undefined;
+    /**
+     * Does filter contain any valid conditions.
+     *
+     */
+    isEmpty(): boolean;
+}
+/**
+ * Class for ordering select results on a number of columns.
+ *
+ */
+export declare class OINOQueryOrder {
+    protected static _orderColumnRegex: RegExp;
+    readonly columns: string[];
+    readonly descending: boolean[];
+    /**
+     * Constructor for `OINOQueryOrder`.
+     *
+     * @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 `OINOQueryOrder` as parser of http parameter.
+     *
+     * Supports comma separated list of column orders formatted as :
+     * - `column` - order by column in ascending order
+     * - `column ASC|DESC` - order by single either ascending or descending order
+     * - `column+|-` - order by single either ascending or descending order
+     *
+     * @param orderString string representation of order from HTTP-request
+     *
+     */
+    static parse(orderString: string): OINOQueryOrder;
+    /**
+     * Does filter contain any valid conditions.
+     *
+     */
+    isEmpty(): boolean;
+}
+/**
+ * Class for limiting the number of results.
+ *
+ */
+export declare class OINOQueryLimit {
+    protected static _limitRegex: RegExp;
+    readonly limit: number;
+    readonly page: number;
+    /**
+     * Constructor for `OINOQueryLimit`.
+     *
+     * @param limit maximum number of items to return
+     * @param page page number to return starting from 1
+     *
+     */
+    constructor(limit: number, page?: number);
+    /**
+     * Constructor for `OINOQueryLimit` as parser of http parameter.
+     *
+     * Supports limit and page formatted as:
+     * - `limit` - limit number of items to return
+     * - `limit page n` - limit number of items to return and return page n (starting from 1)
+     * - `limit.n` - limit number of items to return and return page n (starting from 1)
+     *
+     * @param limitString string representation of limit from HTTP-request
+     *
+     */
+    static parse(limitString: string): OINOQueryLimit;
+    /**
+     * Does filter contain any valid conditions.
+     *
+     */
+    isEmpty(): boolean;
+}
+/**
+ * Class for limiting the number of results.
+ *
+ */
+export declare class OINOQueryAggregate {
+    protected static _aggregateRegex: RegExp;
+    readonly functions: OINOQueryAggregateFunctions[];
+    readonly fields: string[];
+    /**
+     * Constructor for `OINOQueryAggregate`.
+     *
+     * @param functions aggregate function to use
+     * @param fields fields to aggregate
+     *
+     */
+    constructor(functions: OINOQueryAggregateFunctions[], fields: string[]);
+    /**
+     * Constructor for `OINOQueryAggregate` as parser of http parameter.
+     *
+     * Supports comma separated list of aggregates formatted as:
+     * - `function(field)`
+     *
+     * Supported functions are count, sum, avg, min, max.
+     *
+     * @param aggregatorString string representation of limit from HTTP-request
+     *
+     */
+    static parse(aggregatorString: string): OINOQueryAggregate;
+    /**
+     * Does filter contain any valid conditions.
+     *
+     */
+    isEmpty(): boolean;
+    /**
+     * Does filter contain any valid conditions.
+     *
+     * @param field field to check if it is aggregated
+     */
+    isAggregated(field: string): boolean;
+}
+/**
+ * Class for ordering select results on a number of columns.
+ *
+ */
+export declare class OINOQuerySelect {
+    readonly columns: string[];
+    /**
+     * Constructor for `OINOQuerySelect`.
+     *
+     * @param columns array of columns to select
+     *
+     */
+    constructor(columns: string[]);
+    /**
+     * Constructor for `OINOQuerySelect` as parser of http parameter.
+     *
+     * @param columns comma separated string selected columns from HTTP-request
+     *
+     */
+    static parse(columns: string): OINOQuerySelect;
+    /**
+     * Does select contain any valid columns.
+     *
+     */
+    isEmpty(): boolean;
+    /**
+     * Does select include given column.
+     *
+     * @param field field to check if it is selected
+     *
+     */
+    isSelected(field: string): boolean;
+}
+/** Request options */
+export type OINOQueryParams = {
+    /** Additional SQL select where-conditions */
+    filter?: OINOQueryFilter;
+    /** SQL result ordering conditions */
+    order?: OINOQueryOrder;
+    /** SQL result limit condition */
+    limit?: OINOQueryLimit;
+    /** SQL aggregation functions */
+    aggregate?: OINOQueryAggregate;
+    /** SQL select condition */
+    select?: OINOQuerySelect;
+};

package/common/src/OINORequest.d.ts

@@ -1,7 +1,8 @@
 /// <reference types="node" />
 /// <reference types="node" />
 import { Buffer } from "node:buffer";
-import { OINOContentType, OINOHeaders, OINOHeadersInit } from ".";
+import { OINOContentType } from "./OINOConstants.js";
+import { OINOHeaders, type OINOHeadersInit } from "./OINOHeaders.js";
 export interface OINORequestInit {
     params?: Record<string, string>;
 }
@@ -29,6 +30,7 @@ export interface OINOHttpRequestInit extends OINORequestInit {
     body?: OINOHttpData;
     requestType?: OINOContentType;
     responseType?: OINOContentType;
+    responseDownload?: string;
     multipartBoundary?: string;
     lastModified?: number;
 }
@@ -42,6 +44,7 @@ export declare class OINOHttpRequest extends OINORequest {
     body: OINOHttpData;
     requestType: OINOContentType;
     responseType: OINOContentType;
+    responseDownload?: string;
     multipartBoundary?: string;
     lastModified?: number;
     etags?: string[];

package/common/src/OINOResult.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="node" />
 /// <reference types="node" />
 import { Buffer } from "node:buffer";
-import { OINOHeaders, OINOHeadersInit } from ".";
+import { OINOHeaders, type OINOHeadersInit } from "./OINOHeaders.js";
 export interface OINOResultInit {
     success?: boolean;
     status?: number;

package/common/src/OINOStr.d.ts

@@ -1,4 +1,4 @@
-import { OINOContentType } from ".";
+import { OINOContentType } from "./OINOConstants.js";
 /** Callback to filter data fields */
 export type OINOStrEncoder = (str: string) => string;
 /**

package/common/src/OINOSwagger.d.ts

@@ -0,0 +1,25 @@
+import { OINOApi } from "./OINOApi.js";
+/**
+ * Static class for Swagger utilities
+ *
+ */
+export declare class OINOSwagger {
+    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: OINOApi[]): any;
+}

package/common/src/index.d.ts

@@ -1,35 +1,18 @@
+export { OINOApi, OINOApiRequest, OINOApiResult, OINOApiHtmlTemplate, type OINOApiParams, type OINOApiData, type OINOApiRequestInit } from "./OINOApi.js";
 export { OINOBenchmark, OINOMemoryBenchmark } from "./OINOBenchmark.js";
+export { OINOConfig } from "./OINOConfig.js";
+export { OINO_ERROR_PREFIX, OINO_WARNING_PREFIX, OINO_INFO_PREFIX, OINO_DEBUG_PREFIX, OINO_REQUEST_TYPE_PARAM, OINO_RESPONSE_TYPE_PARAM, OINOContentType, type OINODataFieldParams, type OINODataCell, type OINODataRow, OINO_EMPTY_ROW, OINO_EMPTY_ROWS } from "./OINOConstants.js";
+export { OINODataModel } from "./OINODataModel.js";
+export { OINODataSource, OINODataSet, OINOMemoryDataset } from "./OINODataSource.js";
+export { OINODataField, OINOStringDataField, OINONumberDataField, OINOBooleanDataField, OINODatetimeDataField, OINOBlobDataField, type OINODataFieldFilter } from "./OINODataField.js";
+export { OINOFormatter, OINO_EMPTY_FORMATTER } from "./OINOFormatter.js";
+export { OINOHeaders, type OINOHeadersInit } from "./OINOHeaders.js";
+export { OINOHtmlTemplate } from "./OINOHtmlTemplate.js";
 export { OINOLog, OINOLogLevel, OINOConsoleLog } from "./OINOLog.js";
-export { OINOResult, OINOHttpResult, type OINOResultInit, type OINOHttpResultInit } from "./OINOResult.js";
+export { OINOModelSet } from "./OINOModelSet.js";
+export { OINOParser } from "./OINOParser.js";
+export { OINOQueryBooleanOperation, OINOQueryComparison, OINOQueryNullCheck, OINOQueryAggregateFunctions, OINOQuerySelect, OINOQueryFilter, OINOQueryOrder, OINOQueryLimit, OINOQueryAggregate, type OINOQueryParams } from "./OINOQueryParams.js";
 export { OINORequest, OINOHttpRequest, type OINOHttpData, type OINORequestInit, type OINOHttpRequestInit } from "./OINORequest.js";
+export { OINOResult, OINOHttpResult, type OINOResultInit, type OINOHttpResultInit } from "./OINOResult.js";
 export { OINOStr } from "./OINOStr.js";
-export { OINOHtmlTemplate } from "./OINOHtmlTemplate.js";
-export { OINOFormatter, OINO_EMPTY_FORMATTER } from "./OINOFormatter.js";
-export { OINOHeaders, type OINOHeadersInit } from "./OINOHeaders.js";
-/** OINO error message prefix */
-export declare const OINO_ERROR_PREFIX = "OINO ERROR";
-/** OINO warning message prefix */
-export declare const OINO_WARNING_PREFIX = "OINO WARNING";
-/** OINO info message prefix */
-export declare const OINO_INFO_PREFIX = "OINO INFO";
-/** OINO debug message prefix */
-export declare const OINO_DEBUG_PREFIX = "OINO DEBUG";
-/** Name of the OINOContentType-parameter request */
-export declare const OINO_REQUEST_TYPE_PARAM = "oinorequesttype";
-/** Name of the OINOContentType-parameter request */
-export declare const OINO_RESPONSE_TYPE_PARAM = "oinoresponsetype";
-/**
- * Supported content format mime-types
- */
-export declare enum OINOContentType {
-    /** JSON encoded data */
-    json = "application/json",
-    /** CSV encoded data */
-    csv = "text/csv",
-    /** Multipart encoded form data */
-    formdata = "multipart/form-data",
-    /** URL encoded form data */
-    urlencode = "application/x-www-form-urlencoded",
-    /** HTML encoded data (output only) */
-    html = "text/html"
-}
+export { OINOSwagger } from "./OINOSwagger.js";

package/db/src/OINODb.d.ts

@@ -0,0 +1,55 @@
+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 extends OINODataSource {
+    protected readonly dbParams: OINODbParams;
+    /** Name of the database */
+    readonly name: string;
+    isConnected: boolean;
+    isValidated: boolean;
+    /**
+     * Constructor for `OINODb`.
+     * @param params database parameters
+     */
+    constructor(params: OINODbParams);
+    /**
+     * Execute a select operation.
+     *
+     * @param sql SQL statement.
+     *
+     */
+    abstract sqlSelect(sql: string): Promise<OINODataSet>;
+    /**
+     * Execute other sql operations.
+     *
+     * @param sql SQL statement.
+     *
+     */
+    abstract sqlExec(sql: string): Promise<OINODataSet>;
+    /**
+     * 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.
+     * @param groupByCondition - The GROUP BY clause to group the results.
+     *
+     */
+    printSqlSelect(tableName: string, columnNames: string, whereCondition: string, orderCondition: string, limitCondition: string, groupByCondition: string): string;
+    /**
+     * Print SQL select statement with DB specific formatting.
+     *
+     * @param tableName - The name of the table to select from.
+     * @param columns - The columns to be selected.
+     * @param values - The values to be inserted.
+     * @param returnIdFields - the id fields to return if returnIds is true (if supported by the database)
+     *
+     */
+    printSqlInsert(tableName: string, columns: string, values: string, returnIdFields?: string[]): string;
+}

package/db/src/OINODbApi.d.ts

@@ -0,0 +1,78 @@
+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 extends OINOApi {
+    /** DB reference */
+    readonly db: OINODb;
+    /** 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.
+     *
+     * @param db database for the API
+     * @param params parameters for the API
+     *
+     */
+    constructor(db: OINODb, params: OINOApiParams);
+    initializeDatamodel(datamodel: OINODbDataModel): void;
+    private _validateRow;
+    private _parseData;
+    private _doGet;
+    private _doPost;
+    private _doPut;
+    private _doDelete;
+    /**
+     * Method for handling a HTTP REST request with GET, POST, PUT, DELETE corresponding to
+     * SQL select, insert, update and delete.
+     *
+     * @param request OINO HTTP request object containing all parameters of the REST request
+     * @param rowId URL id of the REST request
+     * @param rowData HTTP body data as either serialized string or unserialized JS object or OINODataRow-array or Buffer/Uint8Array binary data
+     * @param queryParams SQL parameters for the REST request
+     *
+     */
+    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.
+     *
+     * @param method HTTP method of the REST request
+     * @param rowId URL id of the REST request
+     * @param rowData HTTP body data as either serialized string or unserialized JS object or OINODataRow-array or Buffer/Uint8Array binary data
+     * @param queryParams SQL parameters for the REST request
+     * @param contentType content type of the HTTP body data, default is JSON
+     *
+     */
+    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.
+     *
+     * @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
+     *
+     */
+    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
+     *
+     */
+    doBatchApiRequest(request: OINOApiRequest): Promise<OINOApiResult>;
+    /**
+     * Method to check if a field is included in the API params.
+     *
+     * @param fieldName name of the field
+     *
+     */
+    isFieldIncluded(fieldName: string): boolean;
+}

package/db/src/OINODbConfig.d.ts

@@ -0,0 +1,56 @@
+/** 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;
+    /** Name of the OINODbSqlAggregate-parameter in request */
+    static OINODB_SQL_AGGREGATE_PARAM: string;
+    /** Name of the OINODbSqlSelect-parameter in request */
+    static OINODB_SQL_SELECT_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/db/src/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 = "";