@egi/smart-db 2.3.1 → 2.3.2

package/src/smart-db-log.ts

@@ -0,0 +1,262 @@
+// 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

@@ -0,0 +1,28 @@
+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
+        };
+    }
+}

package/src/smart-db-upgrade-manager.ts

@@ -0,0 +1,171 @@
+import * as fs from "fs";
+import _ from "lodash";
+import {SmartDbVersionViewModel} from "./models/smart-db-version-view-model";
+import {SmartDb} from "./smart-db";
+import {SmartDbOptions} from "./smart-db-interfaces";
+import {SmartDbLog, SmartDbLogLocation} from "./smart-db-log";
+
+export class SmartDbUpgradeManager {
+    private db: SmartDb;
+    private log: SmartDbLog;
+
+    constructor(db: SmartDb) {
+        this.db = db;
+        this.log = db.getLogger();
+    }
+
+    public hasDatabaseModule(module: string): Promise<boolean> {
+        return new Promise<boolean>((resolve, reject) => {
+            this.db.exists(SmartDbVersionViewModel).then((exists) => {
+                if (exists) {
+                    this.db.getFirst(SmartDbVersionViewModel, {
+                        module: module
+                    }).then((row) => {
+                        resolve(!!row);
+                    }).catch((err) => {
+                        reject(err);
+                    });
+                } else {
+                    resolve(false);
+                }
+            }).catch((err) => {
+                reject(err);
+            });
+        });
+    }
+
+    public prepareDatabase(options: SmartDbOptions): Promise<SmartDbVersionViewModel> {
+        return new Promise<SmartDbVersionViewModel>((resolve, reject) => {
+            try {
+                const dirStat = fs.existsSync(options.sqlFilesDirectory) && fs.statSync(options.sqlFilesDirectory);
+                if (dirStat && dirStat.isDirectory()) {
+                    const initFile = options.sqlFilesDirectory + `/${options.module}-init.sql`;
+                    if (fs.existsSync(initFile)) {
+                        this.hasDatabaseModule(options.module).then((hasDatabase) => {
+                            if (hasDatabase) {
+                                this.log.logInfo(SmartDbLogLocation.UpgradeManager, "prepareDatabase", `database module '${options.module}' exists`);
+                                this.upgradeDatabase(options).then((finalVersionRow) => {
+                                    this.log.logInfo(SmartDbLogLocation.UpgradeManager, "prepareDatabase", `connected to module '${options.module}' version ${finalVersionRow.versionString}`);
+                                    resolve(finalVersionRow);
+                                }).catch((err) => {
+                                    reject(err);
+                                });
+                            } else {
+                                this.log.setDbLogging(false);
+                                this.log.logInfo(SmartDbLogLocation.UpgradeManager, "prepareDatabase", `database '${options.module}' doesn't exists - begin creation`);
+                                this.executeSqlScript(initFile).then(() => {
+                                    this.log.setDbLogging(true);
+                                    this.log.logInfo(SmartDbLogLocation.UpgradeManager, "prepareDatabase", `database module creation complete`);
+                                    this.hasDatabaseModule(options.module).then((hasDatabase) => {
+                                        if (hasDatabase) {
+                                            this.log.logInfo(SmartDbLogLocation.UpgradeManager, "prepareDatabase", `successfully initialized database for new module ${options.module}`);
+                                            this.upgradeDatabase(options).then((finalVersionRow) => {
+                                                this.log.logInfo(SmartDbLogLocation.UpgradeManager, "prepareDatabase", `connected to module '${options.module}' version ${finalVersionRow.versionString}`);
+                                                resolve(finalVersionRow);
+                                            }).catch((err) => {
+                                                reject(err);
+                                            });
+                                        } else {
+                                            reject("error running database initialization script");
+                                        }
+                                    }).catch((err) => {
+                                        reject(err);
+                                    });
+                                }).catch((err) => {
+                                    reject(err);
+                                });
+                            }
+                        }).catch((err) => {
+                            reject(err);
+                        });
+                    } else {
+                        reject(`missing mandatory '${options.module}-init.sql' file in ${initFile}`);
+                    }
+                } else {
+                    reject(`option 'sqlFilesDirectory' (${options.sqlFilesDirectory}) must point to an existing directory (absolute or relative to ${fs.realpathSync(".")})`);
+                }
+            } catch (err) {
+                reject(err);
+            }
+        });
+    }
+
+    private executeSqlScript(script: string): Promise<void> {
+        const sqlData = fs.readFileSync(script, "utf8");
+        return this.db.exec(sqlData);
+    }
+
+    private upgradeDatabase(options: SmartDbOptions): Promise<SmartDbVersionViewModel> {
+        return new Promise<SmartDbVersionViewModel>((resolve, reject) => {
+            this.db.getFirst(SmartDbVersionViewModel, {
+                module: options.module
+            }).then((versionRow) => {
+                if (versionRow) {
+                    fs.readdir(options.sqlFilesDirectory, (err, files) => {
+                        if (err) {
+                            reject(`unable to read database files from ${options.sqlFilesDirectory}`);
+                        } else {
+                            let upgradeScripts: string[] = [];
+                            files.forEach((file) => {
+                                const regExp = new RegExp(`^${options.module}-update.([0-9]{3})\\..*\\.sql$`);
+                                const match = file.match(regExp);
+                                if (match) {
+                                    const sequence = parseInt(match[1], 10);
+                                    if (sequence > versionRow.sequence) {
+                                        upgradeScripts.push(file);
+                                    }
+                                }
+                            });
+
+                            upgradeScripts = _.sortBy(upgradeScripts);
+
+                            this.executeScriptSequentially(upgradeScripts, options).then(() => {
+                                this.db.getFirst(SmartDbVersionViewModel, {module: options.module}, "*", "sequence DESC").then((finalVersionRow) => {
+                                    if (finalVersionRow) {
+                                        resolve(SmartDbVersionViewModel.from(finalVersionRow));
+                                    } else {
+                                        reject("unable to determine final smart db version");
+                                    }
+                                }).catch((err) => {
+                                    reject(err);
+                                });
+                            }).catch((err) => {
+                                reject(err);
+                            });
+                        }
+                    });
+                } else {
+                    reject(`missing version entry for module ${options.module} - add the mandatory insert into smart_db_version statement to your database creation script!`);
+                }
+            }).catch((err) => {
+                reject(err);
+            });
+        });
+    }
+
+    private executeScriptSequentially(scripts: string[], options: SmartDbOptions): Promise<boolean> {
+        return new Promise<boolean>(async (resolve, reject) => {
+            if (scripts && scripts.length > 0) {
+                this.log.logInfo(SmartDbLogLocation.UpgradeManager, "upgradeDatabase", `execute update script '${scripts[0]}' for module ${options.module}`);
+                await this.executeSqlScript(`${options.sqlFilesDirectory}/${scripts[0]}`).then(() => {
+                    this.log.logInfo(SmartDbLogLocation.UpgradeManager, "upgradeDatabase", `successfully executed update script '${scripts[0]}' for module ${options.module}`);
+                    if (scripts.length == 1) {
+                        resolve(true);
+                    }
+                }).catch((err) => {
+                    reject(err);
+                });
+
+                if (scripts.length > 1) {
+                    this.executeScriptSequentially(scripts.splice(1), options).then((status) => {
+                        resolve(status);
+                    }).catch((err) => {
+                        reject(err);
+                    });
+                }
+            } else {
+                resolve(true);
+            }
+        });
+    }
+}