@oino-ts/db 0.0.11

package/src/OINODbSwagger.ts

@@ -0,0 +1,209 @@
+/*
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+import { OINODbApi, OINODbDataField } from "./index.js";
+
+/**
+ * Static class for Swagger utilities
+ *
+ */
+export class OINODbSwagger {
+
+    private static _getSchemaApiMethodParamsQueryId(): any {
+        return {
+            "schema": {
+                "type": "string"
+            },
+            "in": "path",
+            "name": "id",
+            "required": true
+        }
+    }
+
+    private static _getSchemaApiMethodParamsBody(tableName:string): any {
+        return {
+            "schema": {
+                "$ref": "#/components/schemas/" + tableName
+            },
+            "in": "body",
+            "required": true
+        }
+    }
+
+    private static _getSchemaApiMethodDescription(method:string, tableName:string, hasQueryIdParam:boolean): any {
+        if (hasQueryIdParam) {
+            return method.toUpperCase() + " " + tableName + " object"
+        } else {
+            return method.toUpperCase() + " " +tableName + " object array"
+        }
+    }
+
+    private static _getSchemaApiMethodOperationId(method:string, tableName:string, hasQueryIdParam:boolean): any {
+        if (hasQueryIdParam) {
+            return method+tableName
+        } else {
+            return method+tableName+"All"
+        }
+    }
+
+    private static _getSchemaOinoResponse(): any {
+        return {
+            "type": "object",
+            "properties": {
+                "success": {
+                    "type": "boolean"
+                },
+                "statusCode": {
+                    "type": "number"
+                },
+                "statusMessage": {
+                    "type": "string"
+                },
+                "messages": {
+                    "type": "array",
+                    "items": {
+                        "type": "string"
+                    }
+                }
+            },
+            "required": [
+                "success",
+                "statusCode",
+                "statusMessage",
+                "messages"
+            ]
+        }
+    }
+
+    private static _getSchemaFieldType(field:OINODbDataField): any {
+        let type_string: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 }
+        }
+    }
+
+    private static _getSwaggerApiType(api:OINODbApi):any {
+        let result:any = {
+            type: "object",
+            properties: {},
+            required: []
+        }
+        let field:OINODbDataField
+        for (field of api.datamodel.fields) {
+            result.properties[field.name] = this._getSchemaFieldType(field)
+            if (field.fieldParams.isPrimaryKey) {
+                result.required.push(field.name)
+            }
+        }
+        return result
+    }
+
+    private static _getSchemaType(tableName:string, hasQueryIdParam:boolean, hasResultData:boolean) {
+        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" }
+        }
+    }
+
+    private static _getSchemaApiMethodParams(tableName:string, hasQueryIdParam:boolean, hasResultData:boolean) {
+        if (hasResultData && hasQueryIdParam) {
+            return [ this._getSchemaApiMethodParamsQueryId() ]
+
+        } else if (hasResultData) {
+            return []
+
+        } else if (hasQueryIdParam) {
+            return [ this._getSchemaApiMethodParamsQueryId(), this._getSchemaApiMethodParamsBody(tableName) ]
+
+        } else {
+            return [ this._getSchemaApiMethodParamsBody(tableName) ]
+        }
+    }
+
+    private static _getSchemaApiMethod(method:string, tableName:string, hasQueryIdParam:boolean, hasBody:boolean, hasResultData:boolean) {
+        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)
+        }
+    }
+
+    private static _getSwaggerApiPath(tableName:string, hasQueryIdParam:boolean):any {
+
+        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:OINODbApi[]): any {
+        let result:any = {
+            "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/src/index.ts

@@ -0,0 +1,116 @@
+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"
+
+import { OINODb } from "./OINODb.js"
+import { OINODbDataField } from "./OINODbDataField.js"
+import { OINODbSqlFilter, OINODbSqlLimit, OINODbSqlOrder } from "./OINODbRequestParams.js"
+
+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"
+
+/** 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 */
+    hashidRandomIds?: boolean
+}
+
+/** 
+ * 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 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 OINORequestParams = {
+    /** Content type of the request body */
+    requestType?:OINOContentType
+    /** Content type of the response body */
+    responseType?:OINOContentType
+    /** Multipart boundary token */
+    multipartBoundary?: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 const OINODB_EMPTY_ROW:OINODataRow = []
+/** Empty row array instance */
+export const OINODB_EMPTY_ROWS:OINODataRow[] = [OINODB_EMPTY_ROW]
+
+/** Key-value collection */
+export type OINOValues = Record<string, string>
+