@oino-ts/db 0.0.11

package/dist/esm/OINODbSwagger.js

@@ -0,0 +1,197 @@
+/*
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+/**
+ * Static class for Swagger utilities
+ *
+ */
+export class OINODbSwagger {
+    static _getSchemaApiMethodParamsQueryId() {
+        return {
+            "schema": {
+                "type": "string"
+            },
+            "in": "path",
+            "name": "id",
+            "required": true
+        };
+    }
+    static _getSchemaApiMethodParamsBody(tableName) {
+        return {
+            "schema": {
+                "$ref": "#/components/schemas/" + tableName
+            },
+            "in": "body",
+            "required": true
+        };
+    }
+    static _getSchemaApiMethodDescription(method, tableName, hasQueryIdParam) {
+        if (hasQueryIdParam) {
+            return method.toUpperCase() + " " + tableName + " object";
+        }
+        else {
+            return method.toUpperCase() + " " + tableName + " object array";
+        }
+    }
+    static _getSchemaApiMethodOperationId(method, tableName, hasQueryIdParam) {
+        if (hasQueryIdParam) {
+            return method + tableName;
+        }
+        else {
+            return method + tableName + "All";
+        }
+    }
+    static _getSchemaOinoResponse() {
+        return {
+            "type": "object",
+            "properties": {
+                "success": {
+                    "type": "boolean"
+                },
+                "statusCode": {
+                    "type": "number"
+                },
+                "statusMessage": {
+                    "type": "string"
+                },
+                "messages": {
+                    "type": "array",
+                    "items": {
+                        "type": "string"
+                    }
+                }
+            },
+            "required": [
+                "success",
+                "statusCode",
+                "statusMessage",
+                "messages"
+            ]
+        };
+    }
+    static _getSchemaFieldType(field) {
+        let type_string;
+        if (field.type == "boolean") {
+            type_string = "boolean";
+        }
+        else if (field.type == "integer" || field.type == "number") {
+            type_string = "number";
+        }
+        else {
+            type_string = "string";
+        }
+        if (!field.fieldParams.isNotNull) {
+            return {
+                "anyOf": [
+                    {
+                        "type": type_string
+                    },
+                    {
+                        "type": "null"
+                    }
+                ]
+            };
+        }
+        else {
+            return { type: type_string };
+        }
+    }
+    static _getSwaggerApiType(api) {
+        let result = {
+            type: "object",
+            properties: {},
+            required: []
+        };
+        let field;
+        for (field of api.datamodel.fields) {
+            result.properties[field.name] = this._getSchemaFieldType(field);
+            if (field.fieldParams.isPrimaryKey) {
+                result.required.push(field.name);
+            }
+        }
+        return result;
+    }
+    static _getSchemaType(tableName, hasQueryIdParam, hasResultData) {
+        if (hasResultData && hasQueryIdParam) {
+            return { "$ref": "#/components/schemas/" + tableName };
+        }
+        else if (hasResultData) {
+            return { type: "array", items: { "$ref": "#/components/schemas/" + tableName } };
+        }
+        else if (hasQueryIdParam) {
+            return { "$ref": "#/components/schemas/OINOResponse" };
+        }
+        else {
+            return { "$ref": "#/components/schemas/OINOResponse" };
+        }
+    }
+    static _getSchemaApiMethodParams(tableName, hasQueryIdParam, hasResultData) {
+        if (hasResultData && hasQueryIdParam) {
+            return [this._getSchemaApiMethodParamsQueryId()];
+        }
+        else if (hasResultData) {
+            return [];
+        }
+        else if (hasQueryIdParam) {
+            return [this._getSchemaApiMethodParamsQueryId(), this._getSchemaApiMethodParamsBody(tableName)];
+        }
+        else {
+            return [this._getSchemaApiMethodParamsBody(tableName)];
+        }
+    }
+    static _getSchemaApiMethod(method, tableName, hasQueryIdParam, hasBody, hasResultData) {
+        return {
+            responses: {
+                200: { description: this._getSchemaApiMethodDescription(method, tableName, hasQueryIdParam), content: { "application/json": { schema: this._getSchemaType(tableName, hasQueryIdParam, hasResultData) } } }
+            },
+            "operationId": this._getSchemaApiMethodOperationId(method, tableName, hasQueryIdParam),
+            "parameters": this._getSchemaApiMethodParams(tableName, hasQueryIdParam, hasResultData)
+        };
+    }
+    static _getSwaggerApiPath(tableName, hasQueryIdParam) {
+        if (hasQueryIdParam) {
+            return {
+                get: this._getSchemaApiMethod("get", tableName, hasQueryIdParam, false, true),
+                put: this._getSchemaApiMethod("put", tableName, hasQueryIdParam, true, false),
+                delete: this._getSchemaApiMethod("delete", tableName, hasQueryIdParam, false, false)
+            };
+        }
+        else {
+            return {
+                get: this._getSchemaApiMethod("get", tableName, hasQueryIdParam, false, true),
+                post: this._getSchemaApiMethod("post", tableName, hasQueryIdParam, true, false)
+            };
+        }
+    }
+    /**
+     * Returns swagger.json as object of the given API's.
+     *
+     * @param apis array of API's use for Swagger definition
+     *
+     */
+    static getApiDefinition(apis) {
+        let result = {
+            "openapi": "3.1.0",
+            "info": {
+                "title": "",
+                "description": "",
+                "version": ""
+            },
+            "paths": {},
+            "components": {
+                "schemas": {
+                    OINOResponse: this._getSchemaOinoResponse()
+                }
+            }
+        };
+        for (let i = 0; i < apis.length; i++) {
+            const table_name = apis[i].params.tableName;
+            result.paths["/" + table_name] = this._getSwaggerApiPath(table_name, false);
+            result.paths["/" + table_name + "/{id}"] = this._getSwaggerApiPath(table_name, true);
+            result.components.schemas[table_name] = this._getSwaggerApiType(apis[i]);
+        }
+        return result;
+    }
+}

package/dist/esm/index.js

@@ -0,0 +1,17 @@
+import { OINOContentType } from "@oino-ts/types";
+export { OINOContentType };
+export { OINO_ERROR_PREFIX, OINO_WARNING_PREFIX, OINO_INFO_PREFIX, OINO_DEBUG_PREFIX, OINOStr, OINOBenchmark, OINOLog, OINOLogLevel, OINOConsoleLog, OINOResult } from "@oino-ts/types";
+export { OINODbApiResult, 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 { OINODb } from "./OINODb.js";
+export { OINODbDataSet, OINODbMemoryDataSet } from "./OINODbDataSet.js";
+export { OINODbSqlFilter, OINODbSqlOrder, OINODbSqlComparison, OINODbSqlLimit, OINODbSqlBooleanOperation } from "./OINODbRequestParams.js";
+export { OINODbConfig } from "./OINODbConfig.js";
+export { OINODbFactory } from "./OINODbFactory.js";
+export { OINODbSwagger } from "./OINODbSwagger.js";
+/** Empty row instance */
+export const OINODB_EMPTY_ROW = [];
+/** Empty row array instance */
+export const OINODB_EMPTY_ROWS = [OINODB_EMPTY_ROW];

package/dist/types/OINODb.d.ts

@@ -0,0 +1,75 @@
+import { OINODbParams, OINODbApi, OINODataCell, OINODbDataSet } 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>;
+}

package/dist/types/OINODbApi.d.ts

@@ -0,0 +1,57 @@
+import { OINODbApiParams, OINODb, OINODbDataModel, OINODbModelSet, OINORequestParams, OINOResult } from "./index.js";
+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 {
+    /** Returned data if any */
+    data?: OINODbModelSet;
+    /**
+     * Constructor of OINODbApiResult.
+     *
+     * @param data result data
+     *
+     */
+    constructor(data?: OINODbModelSet);
+}
+/**
+ * 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 string
+     * @param params HTTP URL parameters as key-value-pairs
+     *
+     */
+    doRequest(method: string, id: string, body: string, params: OINORequestParams): 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;
+}