@oino-ts/common 0.1.0

package/dist/types/OINOLog.d.ts

@@ -0,0 +1,105 @@
+/** Logging levels */
+export declare enum OINOLogLevel {
+    /** Debug messages */
+    debug = 0,
+    /** Informational messages */
+    info = 1,
+    /** Warning messages */
+    warn = 2,
+    /** Error messages */
+    error = 3
+}
+/**
+ * Abstract base class for logging implementations supporting
+ * - error, warning, info and debug channels
+ * - setting level of logs outputted
+ *
+ */
+export declare abstract class OINOLog {
+    protected static _instance: OINOLog;
+    protected _logLevel: OINOLogLevel;
+    /**
+     * Abstract logging method to implement the actual logging operation.
+     *
+     * @param logLevel level of the log events
+     *
+     */
+    constructor(logLevel?: OINOLogLevel);
+    /**
+     * Abstract logging method to implement the actual logging operation.
+     *
+     * @param levelStr level string of the log event
+     * @param message message of the log event
+     * @param data structured data associated with the log event
+     *
+     */
+    protected abstract _writeLog(levelStr: string, message: string, data?: any): void;
+    /**
+     * Abstract logging method to implement the actual logging operation.
+     *
+     * @param level level of the log event
+     * @param levelStr level string of the log event
+     * @param message message of the log event
+     * @param data structured data associated with the log event
+     *
+     */
+    protected static _log(level: OINOLogLevel, levelStr: string, message: string, data?: any): void;
+    /**
+     * Set active logger and log level.
+     *
+     * @param logger logger instance
+     *
+     */
+    static setLogger(logger: OINOLog): void;
+    /**
+     * Set log level.
+     *
+     * @param logLevel log level to use
+     *
+     */
+    static setLogLevel(logLevel: OINOLogLevel): void;
+    /**
+     * Log error event.
+     *
+     * @param message message of the log event
+     * @param data structured data associated with the log event
+     *
+     */
+    static error(message: string, data?: any): void;
+    /**
+     * Log warning event.
+     *
+     * @param message message of the log event
+     * @param data structured data associated with the log event
+     *
+     */
+    static warning(message: string, data?: any): void;
+    /**
+     * Log info event.
+     *
+     * @param message message of the log event
+     * @param data structured data associated with the log event
+     *
+     */
+    static info(message: string, data?: any): void;
+    /**
+     * Log debug event.
+     *
+     * @param message message of the log event
+     * @param data structured data associated with the log event
+     *
+     */
+    static debug(message: string, data?: any): void;
+}
+/**
+ * Logging implementation based on console.log.
+ *
+ */
+export declare class OINOConsoleLog extends OINOLog {
+    /**
+     * Constructor of `OINOConsoleLog`
+     * @param logLevel logging level
+     */
+    constructor(logLevel?: OINOLogLevel);
+    protected _writeLog(level: string, message: string, data?: any): void;
+}

package/dist/types/OINOParser.d.ts

@@ -0,0 +1,53 @@
+import { OINODbDataModel, OINODataRow, OINODbApiRequestParams } from "../../db/src/index.js";
+/**
+ * Static factory class for easily creating things based on data
+ *
+ */
+export declare class OINOParser {
+    /**
+     * 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 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/OINOResult.d.ts

@@ -0,0 +1,110 @@
+/**
+ * OINO API request result object with returned data and/or http status code/message and
+ * error / warning messages.
+ *
+ */
+export declare class OINOResult {
+    /** Wheter request was successfully executed */
+    success: boolean;
+    /** HTTP status code */
+    statusCode: number;
+    /** HTTP status message */
+    statusMessage: string;
+    /** Error / warning messages */
+    messages: string[];
+    /**
+     * Constructor of OINOResult.
+     *
+     */
+    constructor();
+    /**
+     * Copy values from different result.
+     *
+     * @param result source value
+     */
+    copy(result: OINOResult): void;
+    /**
+     * Set HTTP OK status (does not reset messages).
+     *
+     */
+    setOk(): void;
+    /**
+     * Set HTTP error status using given code and message. Returns self reference for chaining.
+     *
+     * @param statusCode HTTP status code
+     * @param statusMessage HTTP status message
+     * @param operation operation where error occured
+     *
+     */
+    setError(statusCode: number, statusMessage: string, operation: string): OINOResult;
+    /**
+     * Add warning message. Returns self reference for chaining.
+     *
+     * @param message HTTP status message
+     * @param operation operation where warning occured
+     *
+     */
+    addWarning(message: string, operation: string): OINOResult;
+    /**
+     * Add info message. Returns self reference for chaining.
+     *
+     * @param message HTTP status message
+     * @param operation operation where info occured
+     *
+     */
+    addInfo(message: string, operation: string): OINOResult;
+    /**
+     * Add debug message. Returns self reference for chaining.
+     *
+     * @param message HTTP status message
+     * @param operation operation where debug occured
+     *
+     */
+    addDebug(message: string, operation: string): OINOResult;
+    /**
+     * Copy given messages to HTTP headers.
+     *
+     * @param headers HTTP headers
+     * @param copyErrors wether error messages should be copied (default true)
+     * @param copyWarnings wether warning messages should be copied (default false)
+     * @param copyInfos wether info messages should be copied (default false)
+     * @param copyDebug wether debug messages should be copied (default false)
+     *
+     */
+    copyMessagesToHeaders(headers: Headers, copyErrors?: boolean, copyWarnings?: boolean, copyInfos?: boolean, copyDebug?: boolean): void;
+    /**
+     * Print result for logging.
+     *
+     */
+    printLog(): string;
+}
+/**
+ * Specialized result for HTTP responses.
+ */
+export declare class OINOHttpResult extends OINOResult {
+    private _etag;
+    /** HTTP body data */
+    readonly body: string;
+    /** HTTP cache expiration value */
+    expires: number;
+    /** HTTP cache last-modified value */
+    lastModified: number;
+    /**
+     * Constructor for a `OINOHttpResult`
+     *
+     * @param body HTTP body
+     *
+     */
+    constructor(body: string);
+    /**
+     * Get the ETag value for the body opportunistically, i.e. don't calculate until requested and reuse value.
+     *
+     */
+    getEtag(): string;
+    /**
+     * Get a Response object from the result values.
+     *
+     * @param headers HTTP headers (overrides existing values)
+     */
+    getResponse(headers?: Record<string, string>): Response;
+}

package/dist/types/OINOStr.d.ts

@@ -0,0 +1,108 @@
+import { OINOContentType } from ".";
+/** Callback to filter data fields */
+export type OINOStrEncoder = (str: string) => string;
+/**
+ * Static class string utilities.
+ *
+ */
+export declare class OINOStr {
+    /**
+     * Split string by the top level of the given type of brackets.
+     * E.g. splitByBrackets("a(bc(d))ef(gh)kl", true, true, '(', ')') would return ["a", "bc(d)", "ef", "gh", "kl"]
+     *
+     * @param str string to split
+     * @param includePartsBetweenBlocks whether to include strings between top level brackets
+     * @param includeTrailingUnescapedBlock whether to include final block that is missing necessary end brackets
+     * @param startBracket starting bracket, e.g. '('
+     * @param endBracket ending bracket, e.g. ')'
+     *
+     */
+    static splitByBrackets(str: string, includePartsBetweenBlocks: boolean, includeTrailingUnescapedBlock: boolean, startBracket: string, endBracket: string): string[];
+    /**
+     * Split string by delimeter excluding delimeters inside given brackets.
+     * E.g. splitExcludingBrackets("a,(bc,d),ef,(g,h),k", ',', '(', ')') would return ["a", "bc,d", "ef", "g,h", "k"]
+     *
+     * @param str string to split
+     * @param delimeter string to use as delimeter
+     * @param startBracket starting bracket, e.g. '('
+     * @param endBracket ending bracket, e.g. ')'
+     */
+    static splitExcludingBrackets(str: string, delimeter: string, startBracket: string, endBracket: string): string[];
+    /**
+     * Encode OINO serialized strings as valid JSON.
+     *
+     * @param str string to encode
+     * @param valueType wether it is a value type
+     */
+    static encodeJSON(str: string | null | undefined, valueType?: boolean): string;
+    /**
+     * Decode JSON string as OINO serialization.
+     *
+     * @param str string to decode
+     */
+    static decodeJSON(str: string): string;
+    /**
+     * Encode OINO serialized strings as valid CSV.
+     *
+     * @param str string to encode
+     */
+    static encodeCSV(str: string | null | undefined): string;
+    /**
+     * Decode CSV string as OINO serialization.
+     *
+     * @param str string to decode
+     */
+    static decodeCSV(str: string): string;
+    /**
+     * Encode OINO serialized strings as valid Formdata.
+     *
+     * @param str string to encode
+     */
+    static encodeFormdata(str: string | null | undefined): string;
+    /**
+     * Decode Formdata string as OINO serialization.
+     *
+     * @param str string to decode
+     */
+    static decodeFormdata(str: string): string;
+    /**
+     * Encode OINO serialized strings as valid Urlencode.
+     *
+     * @param str string to encode
+     */
+    static encodeUrlencode(str: string | null | undefined): string;
+    /**
+     * Decode Urlencode string as OINO serialization.
+     *
+     * @param str string to decode
+     */
+    static decodeUrlencode(str: string): string;
+    /**
+     * Encode OINO serialized strings as valid HTML content.
+     *
+     * @param str string to encode
+     */
+    static encodeHtml(str: string | null | undefined): string;
+    /**
+     * Decode HTML string as OINO serialization.
+     *
+     * @param str string to encode
+     */
+    static decodeHtml(str: string): string;
+    /**
+     * Decode content type formatted string as OINO serialization.
+     *
+     * @param str string to decode
+     * @param contentType content type for serialization
+     *
+     */
+    static decode(str: string, contentType: OINOContentType): string;
+    /**
+     * Encode OINO serialized string to the content type formatting.
+     *
+     * @param str string to encode
+     * @param contentType content type for serialization
+     *
+     */
+    static encode(str: string | null | undefined, contentType: OINOContentType): string;
+}

package/dist/types/index.d.ts

@@ -0,0 +1,29 @@
+export { OINOBenchmark } from "./OINOBenchmark.js";
+export { OINOLog, OINOLogLevel, OINOConsoleLog } from "./OINOLog.js";
+export { OINOResult, OINOHttpResult } from "./OINOResult.js";
+export { OINOStr } from "./OINOStr.js";
+export { OINOHtmlTemplate } from "./OINOHtmlTemplate.js";
+export { OINOParser } from "./OINOParser";
+/** 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";
+/**
+ * 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"
+}

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@oino-ts/common",
+  "version": "0.1.0",
+  "description": "OINO TS package for common classes.",
+  "author": "Matias Kiviniemi (pragmatta)",
+  "license": "MPL-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/pragmatta/oino-ts.git"
+  },
+  "keywords": [
+    "types",
+    "typescript",
+    "library"
+  ],
+  "main": "./dist/cjs/index.js",
+  "module": "./dist/esm/index.js",
+  "types": "./dist/types/index.d.ts",
+  "dependencies": {
+  },
+  "devDependencies": {
+    "@oino-ts/types": "0.1.0"
+  },
+  "files": [
+    "src/*.ts",
+    "dist/cjs/*.js",
+    "dist/esm/*.js",
+    "dist/types/*.d.ts"
+  ]
+}

package/src/OINOBenchmark.ts

@@ -0,0 +1,112 @@
+/*
+ * 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 benchmarking functions.
+ *
+ */
+export class OINOBenchmark {
+
+    private static _benchmarkCount:Record<string, number> = {}
+    private static _benchmarkData:Record<string, number> = {}
+    private static _benchmarkEnabled:Record<string, boolean> = {}
+    private static _benchmarkStart:Record<string, number> = {}
+
+    /**
+     * Reset benchmark data (but not what is enabled).
+     *
+     */
+    static reset() {
+        this._benchmarkData = {}
+        this._benchmarkCount = {}
+    }
+
+    /**
+     *  Set benchmark names that are enabled.
+     *
+     *  @param module array of those benchmarks that are enabled 
+     */
+    static setEnabled(module:string[]):void {
+        this._benchmarkEnabled = {}
+        module.forEach(module_name => {
+            this._benchmarkEnabled[module_name] = true        
+        });
+    }
+
+    /**
+     * Start benchmark timing.
+     *
+     * @param module of the benchmark
+     * @param method of the benchmark
+     */
+    static start(module:string, method:string):void {
+        const name:string = module + "." + method
+        if (this._benchmarkEnabled[module]) {
+            if (this._benchmarkCount[name] == undefined) {
+                this._benchmarkCount[name] = 0
+                this._benchmarkData[name] = 0
+            }
+            this._benchmarkStart[name] = performance.now()
+        }
+    }
+
+    /**
+     * Complete benchmark timing
+     * 
+     * @param module of the benchmark
+     * @param method of the benchmark
+     * @param category optional subcategory of the benchmark
+     */
+    static end(module:string, method:string, category?:string):number {
+        const name:string = module + "." + method
+        let result:number = 0
+        if (this._benchmarkEnabled[module]) {
+            const duration = performance.now() - this._benchmarkStart[name]
+            this._benchmarkCount[name] += 1
+            this._benchmarkData[name] += duration
+            if (category) {
+                const category_name = name + "." + category
+                if (this._benchmarkCount[category_name] == undefined) {
+                    this._benchmarkCount[category_name] = 0
+                    this._benchmarkData[category_name] = 0
+                }
+                this._benchmarkCount[category_name] += 1
+                this._benchmarkData[category_name] += duration
+            }
+            result = this._benchmarkData[name] / this._benchmarkCount[name]
+        }
+        return result
+    }
+
+    /**
+     * Get given benchmark data.
+     * 
+     * @param module of the benchmark
+     * @param method of the benchmark
+     * 
+     */
+    static get(module:string, method:string):number {
+        const name:string = module + "." + method
+        if (this._benchmarkEnabled[module]) {
+            return this._benchmarkData[module] / this._benchmarkCount[module]
+        }
+        return -1
+    }
+
+    /**
+     * Get all benchmark data.
+     * 
+     */
+    static getAll():number {
+        let result:any = {}
+        for (const name in this._benchmarkData) {
+            if (this._benchmarkCount[name] > 0) {
+                result[name] = this._benchmarkData[name] / this._benchmarkCount[name]
+            }
+        }
+        return result
+    }
+}