@egi/smart-db 2.3.2 → 2.3.4

package/src/models/sqlite-master-model.ts

@@ -1,140 +0,0 @@
-/* eslint-disable @typescript-eslint/member-ordering */
-// noinspection JSUnusedGlobalSymbols
-
-import {ModelAttributeMap} from "../smart-db-interfaces";
-import {AbstractModel} from "./abstract-model";
-
-export interface SqliteMasterModelData extends Record<string, any> {
-    name?: string;
-    type?: string;
-    rootpage?: number;
-    sql?: string;
-}
-
-
-export class SqliteMasterModel extends AbstractModel<SqliteMasterModel, SqliteMasterModelData> {
-    private _type?: string;
-    private _name: string;
-    private _tbl_name?: string;
-    private _rootpage?: number;
-    private _sql?: string;
-
-    static readonly attributeMap: ModelAttributeMap = {
-        type: {
-            type: "string",
-            attribute: "_type"
-        },
-        name: {
-            type: "string",
-            attribute: "_name"
-        },
-        tbl_name: {
-            type: "string",
-            attribute: "_tbl_name"
-        },
-        tblName: {
-            alias: "tbl_name",
-            type: "string",
-            attribute: "_tbl_name"
-        },
-        rootpage: {
-            type: "number",
-            attribute: "_rootpage"
-        },
-        sql: {
-            type: "string",
-            attribute: "_sql"
-        }
-    };
-
-    static getClassName(): string {
-        return "SqliteMasterModel";
-    }
-
-    static getTableName(): string {
-        return "sqlite_master";
-    }
-
-    static from(other: SqliteMasterModel): SqliteMasterModel {
-        let value: SqliteMasterModel = null;
-        if (other) {
-            value = new SqliteMasterModel();
-            if (other instanceof SqliteMasterModel) {
-                Object.assign(value, other);
-            } else {
-                value.assign(other);
-            }
-        }
-        return value;
-    }
-
-    public clone(): SqliteMasterModel {
-        return SqliteMasterModel.from(this);
-    }
-
-    public getClassName(): string {
-        return "SqliteMasterModel";
-    }
-
-    public getTableName(): string {
-        return "sqlite_master";
-    }
-
-    public getAttributeMap(): ModelAttributeMap {
-        return SqliteMasterModel.attributeMap;
-    }
-
-    public getPrimaryKey(): string {
-        return "name";
-    }
-
-    get name(): string {
-        return this._name;
-    }
-
-    set name(name: string) {
-        this._name = name;
-    }
-
-    get rootpage(): number {
-        return this._rootpage;
-    }
-
-    set rootpage(rootpage: number) {
-        this._rootpage = rootpage;
-    }
-
-    get sql(): string {
-        return this._sql;
-    }
-
-    set sql(sql: string) {
-        this._sql = sql;
-    }
-
-    get tblName(): string {
-        return this._tbl_name;
-    }
-
-    set tblName(tblNname: string) {
-        this._tbl_name = tblNname;
-    }
-
-    // noinspection FunctionNamingConventionJS
-    get tbl_name(): string {
-        return this._tbl_name;
-    }
-
-    // noinspection FunctionNamingConventionJS
-    set tbl_name(tblNname: string) {
-        this._tbl_name = tblNname;
-    }
-
-    get type(): string {
-        return this._type;
-    }
-
-    set type(type: string) {
-        this._type = type;
-    }
-}

package/src/models/sqlite-sequence-model.ts

@@ -1,91 +0,0 @@
-/* eslint-disable @typescript-eslint/member-ordering */
-// noinspection JSUnusedGlobalSymbols
-
-import {GenericModelData, ModelAttributeMap, SqlValueType} from "../smart-db-interfaces";
-import {AbstractModel} from "./abstract-model";
-
-export interface SqliteSequenceModelData extends Record<string, any> {
-    name?: SqlValueType;
-    seq?: SqlValueType;
-}
-
-export class SqliteSequenceModel extends AbstractModel <SqliteSequenceModel, SqliteSequenceModelData> {
-    private _name?: SqlValueType;
-    private _seq?: SqlValueType;
-
-    static readonly attributeMap: ModelAttributeMap = {
-        name: {
-            physical: true,
-            typeScriptStyle: true,
-            type: "SqlValueType",
-            attribute: "_name"
-        },
-        seq: {
-            physical: true,
-            typeScriptStyle: true,
-            type: "SqlValueType",
-            attribute: "_seq"
-        }
-    };
-
-    static getClassName(): string {
-        return "SqliteSequenceModel";
-    }
-
-    static getTableName(): string {
-        return "sqlite_sequence";
-    }
-
-    static getPrimaryKey(): string {
-        return "";
-    }
-
-    static from(other: SqliteSequenceModel | GenericModelData): SqliteSequenceModel {
-        let value: SqliteSequenceModel = null;
-        if (other) {
-            value = new SqliteSequenceModel();
-            if (other instanceof SqliteSequenceModel) {
-                Object.assign(value, other);
-            } else {
-                value.assign(other);
-            }
-        }
-        return value;
-    }
-
-    public clone(): SqliteSequenceModel {
-        return SqliteSequenceModel.from(this);
-    }
-
-    public getClassName(): string {
-        return "SqliteSequenceModel";
-    }
-
-    public getTableName(): string {
-        return "sqlite_sequence";
-    }
-
-    public getPrimaryKey(): string {
-        return "";
-    }
-
-    public getAttributeMap(): ModelAttributeMap {
-        return SqliteSequenceModel.attributeMap;
-    }
-
-    get name(): SqlValueType {
-        return this._name;
-    }
-
-    set name(name: SqlValueType) {
-        this._name = name;
-    }
-
-    get seq(): SqlValueType {
-        return this._seq;
-    }
-
-    set seq(seq: SqlValueType) {
-        this._seq = seq;
-    }
-}

package/src/smart-db-globals.ts

@@ -1,136 +0,0 @@
-import _ from "lodash";
-import {SqlFieldDescriptor, SqlFieldOperationType, SqlOperation, SqlOperationType, SqlValueType} from "./smart-db-interfaces";
-
-export const OP = (op: SqlOperationType, value?: SqlValueType | SqlValueType[], key?: string, literalOp?: SqlOperationType): SqlOperation => {
-    return key ? {
-        operation: op,
-        value: value,
-        key: key,
-        literalOperation: literalOp
-    } : {
-        operation: op,
-        value: value
-    };
-};
-// noinspection JSUnusedGlobalSymbols
-export const VALUE = (value: SqlValueType, alias?: string, literal?: boolean): SqlFieldDescriptor => {
-    return {
-        operation: SqlFieldOperationType.VALUE,
-        value: value,
-        alias: alias,
-        literal: literal
-    };
-};
-// noinspection JSUnusedGlobalSymbols
-export const FIELD = (value: string, alias?: string): SqlFieldDescriptor => {
-    return {
-        operation: SqlFieldOperationType.FIELD,
-        value: value,
-        alias: alias
-    };
-};
-// noinspection JSUnusedGlobalSymbols
-export const COUNT = (value?: string, alias?: string): SqlFieldDescriptor => {
-    return {
-        operation: SqlFieldOperationType.COUNT,
-        value: value,
-        alias: alias
-    };
-};
-// noinspection JSUnusedGlobalSymbols
-export const COALESCE = (values: (SqlFieldDescriptor | SqlValueType)[], alias?: string): SqlFieldDescriptor => {
-    return {
-        operation: SqlFieldOperationType.COALESCE,
-        value: values,
-        alias: alias
-    };
-};
-// noinspection JSUnusedGlobalSymbols
-export const NVL = (values: (SqlFieldDescriptor | SqlValueType)[], alias?: string): SqlFieldDescriptor => {
-    return COALESCE(values, alias);
-};
-// noinspection JSUnusedGlobalSymbols
-export const LITERAL = (key: string, value: SqlValueType, op?: SqlOperationType): SqlOperation => {
-    return OP(SqlOperationType.LITERAL, value, key, op || SqlOperationType.EQ);
-};
-// noinspection JSUnusedGlobalSymbols
-export const GT = (value: SqlValueType): SqlOperation => {
-    return OP(SqlOperationType.GT, value);
-};
-// noinspection JSUnusedGlobalSymbols
-export const GE = (value: SqlValueType): SqlOperation => {
-    return OP(SqlOperationType.GE, value);
-};
-// noinspection JSUnusedGlobalSymbols
-export const LT = (value: SqlValueType): SqlOperation => {
-    return OP(SqlOperationType.LT, value);
-};
-// noinspection JSUnusedGlobalSymbols
-export const LE = (value: SqlValueType): SqlOperation => {
-    return OP(SqlOperationType.LE, value);
-};
-// noinspection JSUnusedGlobalSymbols
-export const EQ = (value: SqlValueType): SqlOperation => {
-    return OP(SqlOperationType.EQ, value);
-};
-// noinspection JSUnusedGlobalSymbols
-export const NE = (value: any): SqlOperation => {
-    return OP(SqlOperationType.NE, value);
-};
-// noinspection JSUnusedGlobalSymbols
-export const IN = (value: SqlValueType[]): SqlOperation => {
-    return OP(SqlOperationType.IN, value);
-};
-// noinspection JSUnusedGlobalSymbols
-export const IS_NULL = (): SqlOperation => {
-    return OP(SqlOperationType.IS_NULL);
-};
-// noinspection JSUnusedGlobalSymbols
-export const IS_NOT_NULL = (): SqlOperation => {
-    return OP(SqlOperationType.IS_NOT_NULL);
-};
-export const SmartDbDateRegexp = /^(\d{4}-[01]\d-[0-3]\d [0-2]\d:[0-5]\d:[0-5]\d)(Z| GMT| GMT[-+]\d{1,2})?$/;
-export const SmartDbTimestampRegexp = /^(\d{4}-[01]\d-[0-3]\d [0-2]\d:[0-5]\d:[0-5]\d\.\d{3})(Z| GMT| GMT[-+]\d{1,2})?$/;
-
-export function toSmartDbDate(d: Date | number): string {
-    let dateString: string;
-    if (d) {
-        if (_.isNumber(d)) {
-            d = new Date(d);
-        }
-
-        dateString = d.toISOString().substr(0, 19).replace("T", " ");
-    }
-
-    return dateString;
-}
-
-export function toSmartDbTimestamp(d: Date | number): string {
-    let timestampString: string;
-    if (d) {
-        if (_.isNumber(d)) {
-            d = new Date(d);
-        }
-
-        timestampString = d.toISOString().substr(0, 23).replace("T", " ");
-    }
-
-    return timestampString;
-}
-
-// noinspection JSUnusedGlobalSymbols
-export function smartDbToDate(d: Date | number | string): Date | null {
-    let date: Date = null;
-
-    if (_.isDate(d)) {
-        date = d;
-    } else if (_.isNumber(d)) {
-        date = new Date(d);
-    } else if (_.isString(d)) {
-        if (d.match(SmartDbDateRegexp) || d.match(SmartDbTimestampRegexp)) {
-            date = new Date(d);
-        }
-    }
-
-    return date;
-}

package/src/smart-db-log.ts

@@ -1,262 +0,0 @@
-// noinspection JSUnusedGlobalSymbols
-
-import _ from "lodash";
-import {SmartDbLogModel, SmartDbLogModelData} from "./models/smart-db-log-model";
-import {SmartDbDateRegexp, SmartDbTimestampRegexp, toSmartDbTimestamp} from "./smart-db-globals";
-import {SmartDbApi} from "./smart-db-interfaces";
-
-export const SmartDbLogLocation = {
-    Frontend: "frontend",
-    Backend: "backend",
-    Database: "database",
-    UpgradeManager: "upgrade-manager",
-    Other: "other"
-};
-
-export type SmartDbLogLocationType = typeof SmartDbLogLocation;
-export type SmartDbLogLocationKey = keyof SmartDbLogLocationType;
-export type SmartDbLogLocationValue = SmartDbLogLocationType[keyof SmartDbLogLocationType];
-
-export const SeverityCode = {
-    Fatal: "F", Error: "E", Warning: "W", Info: "I", Debug: "D", Local: "L"
-} as const;
-
-export type SeverityCodeType = typeof SeverityCode;
-export type SeverityCodeKey = keyof SeverityCodeType;
-export type SeverityCodeValue = SeverityCodeType[keyof SeverityCodeType];
-
-export const SeverityLevel = {
-    None: 0, Fatal: 1, Error: 2, Warning: 3, Info: 4, Debug: 5, All: 9
-} as const;
-
-export type SeverityLevelType = typeof SeverityLevel;
-export type SeverityLevelKey = keyof SeverityLevelType;
-export type SeverityLevelValue = SeverityLevelType[keyof SeverityLevelType];
-
-export class SmartDbLog {
-    private db: SmartDbApi;
-    private dbLogLevel: SeverityLevelValue; // = SeverityLevel.Info;
-    private consoleLogLevel: SeverityLevelValue; //= SeverityLevel.Info;
-    private userId: string | number = null;
-    private dbLogging: boolean = true;
-    private isLogging: boolean = false;
-
-    constructor(db?: SmartDbApi) {
-        this.db = db;
-        this.dbLogLevel = SeverityLevel.Info;
-        this.consoleLogLevel = SeverityLevel.Info;
-    }
-
-    // noinspection JSUnusedGlobalSymbols
-    public getConsoleLogLevel(): SeverityLevelValue {
-        return this.consoleLogLevel;
-    }
-
-    public setConsoleLogLevel(consoleLogLevel: SeverityLevelValue): void {
-        this.consoleLogLevel = consoleLogLevel;
-    }
-
-    // noinspection JSUnusedGlobalSymbols
-    public getDbLogLevel(): SeverityLevelValue {
-        return this.dbLogLevel;
-    }
-
-    public setDbLogLevel(dbLogLevel: SeverityLevelValue): void {
-        this.dbLogLevel = dbLogLevel;
-    }
-
-    public setDb(db: SmartDbApi): void {
-        this.db = db;
-
-        if (this.db) {
-            this.db.exists(SmartDbLogModel).then((exists) => {
-                this.dbLogging = exists;
-            }).catch((err) => {
-                throw err;
-            });
-        } else {
-            this.dbLogging = false;
-        }
-    }
-
-    public setUserId(userId: string | number): void {
-        this.userId = userId;
-    }
-
-    public setDbLogging(dbLogging: boolean) {
-        this.dbLogging = dbLogging;
-    }
-
-    public getDbLogging(): boolean {
-        return this.dbLogging;
-    }
-
-    public logFatal(type: SmartDbLogLocationValue, location: string, message: string | Error, data?: any): void {
-        this.writeLog(type, location, SeverityCode.Fatal, message, data);
-    }
-
-    public logError(type: SmartDbLogLocationValue, location: string, message: string | Error, data?: any): void {
-        this.writeLog(type, location, SeverityCode.Error, message, data);
-    }
-
-    public logWarning(type: SmartDbLogLocationValue, location: string, message: string | Error, data?: any): void {
-        this.writeLog(type, location, SeverityCode.Warning, message, data);
-    }
-
-    public logInfo(type: SmartDbLogLocationValue, location: string, message: string | Error, data?: any): void {
-        this.writeLog(type, location, SeverityCode.Info, message, data);
-    }
-
-    public logDebug(type: SmartDbLogLocationValue, location: string, message: string | Error, data?: any): void {
-        this.writeLog(type, location, SeverityCode.Debug, message, data);
-    }
-
-    // noinspection OverlyComplexFunctionJS,FunctionTooLongJS
-    public writeLog(type: SmartDbLogLocationValue, location: string, severity: SeverityCodeValue, message: string | Error, data: unknown, timestamp?: Date | string | number): void {
-        try {
-            if (this.isLogging) {
-                console.error("recursive logging error:", type, location, severity, message, data);
-            } else {
-                this.isLogging = true;
-
-                let logLevel: SeverityLevelValue = SeverityLevel.None;
-                let logFn: (message?: any, ...args: any[]) => void;
-
-                switch (severity) {
-                    case SeverityCode.Fatal:
-                        logFn = console.error;
-                        logLevel = SeverityLevel.Fatal;
-                        break;
-
-                    case SeverityCode.Error:
-                        logFn = console.error;
-                        logLevel = SeverityLevel.Error;
-                        break;
-
-                    case SeverityCode.Warning:
-                        logFn = console.warn;
-                        logLevel = SeverityLevel.Warning;
-                        break;
-
-                    case SeverityCode.Info:
-                        logFn = console.info;
-                        logLevel = SeverityLevel.Info;
-                        break;
-
-                    case SeverityCode.Debug:
-                        logFn = console.debug;
-                        logLevel = SeverityLevel.Debug;
-                        break;
-                }
-
-                let timestampString: string;
-
-                if (_.isString(timestamp)) {
-                    const timestampMatch = timestamp.match(SmartDbTimestampRegexp);
-                    const dateMatch = timestampMatch && timestamp.match(SmartDbDateRegexp);
-                    if (timestampMatch) {
-                        timestampString = timestampMatch[1];
-                    } else if (dateMatch) {
-                        timestampString = dateMatch[1] + ".000";
-                    } else {
-                        timestampString = toSmartDbTimestamp(new Date());
-                    }
-                } else if (_.isDate(timestamp)) {
-                    timestampString = toSmartDbTimestamp(timestamp);
-                } else if (_.isNumber(timestamp)) {
-                    timestampString = toSmartDbTimestamp(new Date(timestamp));
-                } else {
-                    timestampString = toSmartDbTimestamp(new Date());
-                }
-
-                if (_.isObjectLike(message)) {
-                    if (message instanceof Error) {
-                        if (!data) {
-                            data = message;
-                        }
-                        message = message.message;
-                    } else {
-                        try {
-                            message = JSON.stringify(message);
-                        } catch (err) {
-                            message = message.toString();
-                        }
-                    }
-                } else if (typeof <any>message === "boolean") {
-                    message = message ? "<true>" : "<false>";
-                }
-
-                if (data) {
-                    if (data instanceof Error) {
-                        data = data.stack;
-                    } else if (_.isObject(data)) {
-                        try {
-                            data = JSON.stringify(data);
-                        } catch (err) {
-                            data = data.toString();
-
-                            if (this.db && this.dbLogLevel >= logLevel) {
-                                console.error("unable to stringify log data", data);
-                            }
-                        }
-                    } else if (data.toString) {
-                        data = data.toString();
-                    } else {
-                        data = null;
-
-                        if (this.db && this.dbLogLevel >= logLevel) {
-                            console.error("unable to store log data", data);
-                        }
-                    }
-
-                    if (data) {
-                        message += ` (${data})`;
-                    }
-                }
-
-                if (this.consoleLogLevel >= logLevel) {
-                    const shortType = type.substr(0, 1).toUpperCase();
-                    if (type == SmartDbLogLocation.Database && this.db) {
-                        logFn(`${severity}-${shortType}-${timestampString}: last statement:`, this.db.getLastBuildData());
-                    }
-
-                    logFn(`${severity}-${shortType}-${timestampString}: ${message}`);
-
-                    if (this.dbLogging) {
-                        try {
-                            if (type == SmartDbLogLocation.Database) {
-                                if (!data) {
-                                    data = JSON.stringify(this.db.getLastBuildData());
-                                }
-                            }
-
-                            this.db.insertSync(SmartDbLogModel, <SmartDbLogModelData>{
-                                severity: severity,
-                                type: type,
-                                location: location,
-                                info: message || "<empty>",
-                                data: data as string,
-                                user: this.userId,
-                                timestamp: new Date(timestampString)
-                            });
-                        } catch (error) {
-                            console.error(`F-B-${timestampString}: unable to write the log statement below to database`, error, error.code, error.name, error.message);
-                            try {
-                                logFn(`F-B-${timestampString}: last statement:`, this.db.getLastBuildData());
-                            } catch {
-                                logFn(`F-B-${timestampString}: last statement not available`);
-                            }
-                        }
-                    }
-                }
-            }
-
-            this.isLogging = false;
-        } catch (error) {
-            this.isLogging = false;
-            console.error("fatal logging error", error);
-        }
-    }
-}
-
-export const smartDbLog: SmartDbLog = new SmartDbLog();

package/src/smart-db-sql-build-data.ts

@@ -1,28 +0,0 @@
-import _ from "lodash";
-import {SmartDbSqlBuildDataResults, SqlValueType} from "./smart-db-interfaces";
-
-export class SmartDbSqlBuildData {
-    public sql: string;
-    public values: SqlValueType[];
-
-    constructor(sql?: string, values?: SqlValueType[]) {
-        this.sql = sql || "";
-        this.values = values || [];
-    }
-
-    public append(data: SmartDbSqlBuildData): void {
-        this.sql = this.sql.trim() + " " + data.sql.trim();
-        this.values = _.concat(this.values, data.values);
-    }
-
-    public toString() {
-        return this.sql + " <= (" + this.values.join(", ") + ")";
-    }
-
-    public results(): SmartDbSqlBuildDataResults {
-        return {
-            sql: this.sql,
-            values: this.values
-        };
-    }
-}