@egi/smart-db 2.3.2 → 2.3.4

package/src/models/abstract-model.ts

@@ -1,209 +0,0 @@
-import _ from "lodash";
-import {FieldNamingStyle, GenericModelData, ModelAttributeMap, SqlValueType} from "../smart-db-interfaces";
-
-export abstract class AbstractModel<T extends AbstractModel<T, D>, D extends GenericModelData> {
-    public abstract clone(): T;
-
-    public abstract getClassName(): string;
-
-    public abstract getTableName(): string;
-
-    public abstract getPrimaryKey(): string;
-
-    public abstract getAttributeMap(): ModelAttributeMap;
-
-    // overload this in child class
-    static readonly attributeMap: ModelAttributeMap = {};
-
-    static getTableName(): string {
-        return "overload this in child class";
-    }
-
-    static from(other: any): any {
-        // overload this in child class
-    }
-
-    public assign(other: T | D, options?: { only?: string[]; exclude?: string[]; skipUndefined?: boolean }): void {
-        if (typeof other == "object") {
-            const attributeMap = this.getAttributeMap();
-            let skipUndefined = !options || !!options.skipUndefined;
-            Object.keys(attributeMap).forEach((attribute) => {
-                let ok = true;
-                if (options) {
-                    if (options.only && !_.includes(options.only, attribute)) {
-                        ok = false;
-                    }
-
-                    if (options.exclude && _.includes(options.exclude, attribute)) {
-                        ok = false;
-                    }
-                }
-
-                if (ok) {
-                    if (other instanceof AbstractModel && other.hasAttribute(attribute)) {
-                        const otherValue = other.getValue(attribute);
-                        if (!skipUndefined || otherValue !== undefined) {
-                            this.setValue(attribute, otherValue);
-                        }
-                    } else {
-                        if (other.hasOwnProperty(attribute)) {
-                            const otherValue: string | number = (<any>other)[attribute] as (string | number);
-                            if (!skipUndefined || otherValue !== undefined) {
-                                this.setValue(attribute, otherValue);
-                            }
-                        }
-                    }
-                }
-            });
-        }
-    }
-
-    // noinspection OverlyComplexFunctionJS
-    public setValue(attribute: string, value: string | number | boolean | Date): void {
-        const info = this.getAttributeMap()[attribute];
-        if (info) {
-            if (value === null) {
-                (<Record<string, any>>this)[info.attribute] = null;
-            } else if (value === undefined) {
-                delete (<Record<string, any>>this)[info.attribute];
-            } else {
-                switch (info.type) {
-                    case "SqlValueType":
-                        break;
-
-                    case "string":
-                        if (_.isNumber(value)) {
-                            value = value.toString();
-                        } else if (_.isBoolean(value)) {
-                            value = value ? "true" : "false";
-                        } else if (_.isDate(value)) {
-                            value = this.toDbTimestamp(value);
-                        }
-                        break;
-
-                    case "number":
-                        if (_.isString(value)) {
-                            value = parseFloat(value);
-                        } else if (_.isBoolean(value)) {
-                            value = value ? 1 : 0;
-                        } else if (_.isDate(value)) {
-                            value = value.getTime();
-                        }
-                        break;
-
-                    case "boolean":
-                        if (_.isString(value)) {
-                            value = !value.match(/(F|N|false|no|0)/i);
-                        } else if (_.isNumber(value)) {
-                            value = !!value;
-                        } else if (_.isDate(value)) {
-                            value = true;
-                        }
-                        break;
-
-                    case "Date":
-                        if (_.isString(value)) {
-                            if (value.match(/^\d{4}-[01][0-9]-[0-3][0-9][ T][0-2][0-9]:[0-5][0-9]:[0-5][0-9]\s*$/)) {
-                                value += " GMT";
-                            }
-                        }
-
-                        if (_.isNumber(value) || _.isString(value) || _.isDate(value)) {
-                            value = new Date(value);
-                        } else {
-                            value = new Date();
-                        }
-                        break;
-
-                    default:
-                        throw `AbstractModel.setValue: unknown data type '${info.type}'`;
-                }
-
-                (<Record<string, any>>this)[info.attribute] = value;
-
-            }
-        } else {
-            throw `unknown attribute ${attribute} for ${this.getClassName()}`;
-        }
-    }
-
-    public getValue(attribute: string): string | number | boolean {
-        const info = this.getAttributeMap()[attribute];
-        return (<Record<string, any>>this)[info.attribute] as (string | number | boolean);
-    }
-
-    public hasAttribute(attribute: string): boolean {
-        return !!this.getAttributeMap()[attribute];
-    }
-
-    // noinspection JSUnusedGlobalSymbols
-    public clear(attributes: string | string[]): void {
-        if (!_.isArray(attributes)) {
-            attributes = [attributes];
-        }
-        const attributeMap = this.getAttributeMap();
-
-        attributes.forEach((attribute) => {
-            const info = attributeMap[attribute];
-            if (info) {
-                delete (<Record<string, any>>this)[info.attribute];
-            }
-        });
-    }
-
-    public getPlainObject(style: FieldNamingStyle, includeVirtuals?: boolean, fields?: string[]): D {
-        const attributeMap = this.getAttributeMap();
-        const plainObjectFields: string[] = [];
-
-        if (includeVirtuals === undefined) {
-            includeVirtuals = true;
-        }
-
-        _.forOwn(attributeMap, (info, attribute) => {
-            let includeAttribute = style == FieldNamingStyle.All || (includeVirtuals && info.virtual);
-            if (!includeAttribute) {
-                if (style == FieldNamingStyle.Database) {
-                    includeAttribute = info.physical;
-                } else if (style == FieldNamingStyle.TypeScript) {
-                    includeAttribute = info.typeScriptStyle;
-                } else {
-                    throw `unknown style ${style}`;
-                }
-            }
-
-            if (includeAttribute) {
-                if (!fields || _.includes(fields, attribute)) {
-                    plainObjectFields.push(attribute);
-                }
-            }
-        });
-
-        const plainObject: Record<string, SqlValueType> = {};
-
-        plainObjectFields.forEach((attribute) => {
-            const info = attributeMap[attribute];
-            if (info) {
-                const value = (<Record<string, any>>this)[info.attribute] as SqlValueType;
-                if (value !== undefined) {
-                    plainObject[attribute] = value;
-                }
-            }
-        });
-
-        return plainObject as D;
-    }
-
-    // noinspection JSMethodCanBeStatic
-    private toDbTimestamp(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;
-    }
-}

package/src/models/smart-db-core-table-model.ts

@@ -1,161 +0,0 @@
-/* eslint-disable @typescript-eslint/member-ordering */
-// noinspection JSUnusedGlobalSymbols
-
-import {GenericModelData, ModelAttributeMap} from "../smart-db-interfaces";
-import {AbstractModel} from "./abstract-model";
-
-export interface SmartDbCoreTableModelData extends GenericModelData {
-    id?: number;
-    name?: string;
-    type?: string;
-}
-
-export class SmartDbCoreTableModel extends AbstractModel<SmartDbCoreTableModel, SmartDbCoreTableModelData> {
-    private _id?: number;
-    private _name?: string;
-    private _type?: string;
-
-    static readonly attributeMap: ModelAttributeMap = {
-        id: {
-            alias: "ctb_id",
-            typeScriptStyle: true,
-            type: "number",
-            attribute: "_id"
-        },
-        ctb_id: {
-            physical: true,
-            type: "number",
-            attribute: "_id"
-        },
-        name: {
-            alias: "ctb_name",
-            typeScriptStyle: true,
-            type: "string",
-            attribute: "_name"
-        },
-        ctb_name: {
-            physical: true,
-            type: "string",
-            attribute: "_name"
-        },
-        type: {
-            alias: "ctb_type",
-            typeScriptStyle: true,
-            type: "string",
-            attribute: "_type"
-        },
-        ctb_type: {
-            physical: true,
-            type: "string",
-            attribute: "_type"
-        }
-    };
-
-    constructor(data?: SmartDbCoreTableModel | SmartDbCoreTableModelData) {
-        super();
-        if (data) {
-            this.assign(data);
-        }
-    }
-
-    static getClassName(): string {
-        return "SmartDbCoreTableModel";
-    }
-
-    static getTableName(): string {
-        return "smart_db_core_table";
-    }
-
-    static getPrimaryKey(): string {
-        return "ctb_id";
-    }
-
-    static from(other: SmartDbCoreTableModel | SmartDbCoreTableModelData): SmartDbCoreTableModel {
-        let value: SmartDbCoreTableModel = null;
-        if (other) {
-            value = new SmartDbCoreTableModel();
-            if (other instanceof SmartDbCoreTableModel) {
-                Object.assign(value, other);
-            } else {
-                value.assign(other);
-            }
-        }
-        return value;
-    }
-
-    public clone(): SmartDbCoreTableModel {
-        return SmartDbCoreTableModel.from(this);
-    }
-
-    public getClassName(): string {
-        return "SmartDbCoreTableModel";
-    }
-
-    public getTableName(): string {
-        return "smart_db_core_table";
-    }
-
-    public getPrimaryKey(): string {
-        return "ctb_id";
-    }
-
-    public getAttributeMap(): ModelAttributeMap {
-        return SmartDbCoreTableModel.attributeMap;
-    }
-
-    // noinspection FunctionNamingConventionJS
-    get ctb_id(): number {
-        return this._id;
-    }
-
-    // noinspection FunctionNamingConventionJS
-    set ctb_id(id: number) {
-        this._id = id;
-    }
-
-    // noinspection FunctionNamingConventionJS
-    get ctb_name(): string {
-        return this._name;
-    }
-
-    // noinspection FunctionNamingConventionJS
-    set ctb_name(name: string) {
-        this._name = name;
-    }
-
-    // noinspection FunctionNamingConventionJS
-    get ctb_type(): string {
-        return this._type;
-    }
-
-    // noinspection FunctionNamingConventionJS
-    set ctb_type(type: string) {
-        this._type = type;
-    }
-
-    // noinspection FunctionNamingConventionJS
-    get id(): number {
-        return this._id;
-    }
-
-    // noinspection FunctionNamingConventionJS
-    set id(id: number) {
-        this._id = id;
-    }
-
-    get name(): string {
-        return this._name;
-    }
-
-    set name(name: string) {
-        this._name = name;
-    }
-
-    get type(): string {
-        return this._type;
-    }
-
-    set type(type: string) {
-        this._type = type;
-    }
-}

package/src/models/smart-db-dictionary.ts

@@ -1,28 +0,0 @@
-import {SmartDbCoreTableModel} from "./smart-db-core-table-model";
-import {SmartDbLogModel} from "./smart-db-log-model";
-import {SmartDbVersionModel} from "./smart-db-version-model";
-import {SmartDbVersionViewModel} from "./smart-db-version-view-model";
-
-interface SmartDbDictionaryEntry {
-    cls: typeof SmartDbCoreTableModel |
-        typeof SmartDbLogModel |
-        typeof SmartDbVersionModel |
-        typeof SmartDbVersionViewModel;
-}
-
-export class SmartDbDictionary {
-    static models: { [relation: string]: SmartDbDictionaryEntry; } = {
-        SmartDbCoreTableModel: {
-            cls: SmartDbCoreTableModel
-        },
-        SmartDbLogModel: {
-            cls: SmartDbLogModel
-        },
-        SmartDbVersionModel: {
-            cls: SmartDbVersionModel
-        },
-        SmartDbVersionViewModel: {
-            cls: SmartDbVersionViewModel
-        }
-    };
-}

package/src/models/smart-db-log-model.ts

@@ -1,316 +0,0 @@
-/* eslint-disable @typescript-eslint/member-ordering */
-// noinspection JSUnusedGlobalSymbols
-
-import {GenericModelData, ModelAttributeMap} from "../smart-db-interfaces";
-import {AbstractModel} from "./abstract-model";
-
-export interface SmartDbLogModelData extends GenericModelData {
-    id?: number;
-    severity?: string;
-    type?: string;
-    location?: string;
-    info?: string;
-    data?: string;
-    user?: string;
-    timestamp?: Date;
-}
-
-export class SmartDbLogModel extends AbstractModel<SmartDbLogModel, SmartDbLogModelData> {
-    private _id?: number;
-    private _severity?: string;
-    private _type?: string;
-    private _location?: string;
-    private _info?: string;
-    private _data?: string;
-    private _user?: string;
-    private _timestamp?: Date;
-
-    static readonly attributeMap: ModelAttributeMap = {
-        id: {
-            alias: "log_id",
-            typeScriptStyle: true,
-            type: "number",
-            attribute: "_id"
-        },
-        log_id: {
-            physical: true,
-            type: "number",
-            attribute: "_id"
-        },
-        severity: {
-            alias: "log_severity",
-            typeScriptStyle: true,
-            type: "string",
-            attribute: "_severity"
-        },
-        log_severity: {
-            physical: true,
-            type: "string",
-            attribute: "_severity"
-        },
-        type: {
-            alias: "log_type",
-            typeScriptStyle: true,
-            type: "string",
-            attribute: "_type"
-        },
-        log_type: {
-            physical: true,
-            type: "string",
-            attribute: "_type"
-        },
-        location: {
-            alias: "log_location",
-            typeScriptStyle: true,
-            type: "string",
-            attribute: "_location"
-        },
-        log_location: {
-            physical: true,
-            type: "string",
-            attribute: "_location"
-        },
-        info: {
-            alias: "log_info",
-            typeScriptStyle: true,
-            type: "string",
-            attribute: "_info"
-        },
-        log_info: {
-            physical: true,
-            type: "string",
-            attribute: "_info"
-        },
-        data: {
-            alias: "log_data",
-            typeScriptStyle: true,
-            type: "string",
-            attribute: "_data"
-        },
-        log_data: {
-            physical: true,
-            type: "string",
-            attribute: "_data"
-        },
-        user: {
-            alias: "log_user",
-            typeScriptStyle: true,
-            type: "string",
-            attribute: "_user"
-        },
-        log_user: {
-            physical: true,
-            type: "string",
-            attribute: "_user"
-        },
-        timestamp: {
-            alias: "log_timestamp",
-            typeScriptStyle: true,
-            type: "Date",
-            attribute: "_timestamp"
-        },
-        log_timestamp: {
-            physical: true,
-            type: "Date",
-            attribute: "_timestamp"
-        }
-    };
-
-    constructor(data?: SmartDbLogModel | SmartDbLogModelData) {
-        super();
-        if (data) {
-            this.assign(data);
-        }
-    }
-
-    static getClassName(): string {
-        return "SmartDbLogModel";
-    }
-
-    static getTableName(): string {
-        return "smart_db_log";
-    }
-
-    static getPrimaryKey(): string {
-        return "log_id";
-    }
-
-    static from(other: SmartDbLogModel | SmartDbLogModelData): SmartDbLogModel {
-        let value: SmartDbLogModel = null;
-        if (other) {
-            value = new SmartDbLogModel();
-            if (other instanceof SmartDbLogModel) {
-                Object.assign(value, other);
-            } else {
-                value.assign(other);
-            }
-        }
-        return value;
-    }
-
-    public clone(): SmartDbLogModel {
-        return SmartDbLogModel.from(this);
-    }
-
-    public getClassName(): string {
-        return "SmartDbLogModel";
-    }
-
-    public getTableName(): string {
-        return "smart_db_log";
-    }
-
-    public getPrimaryKey(): string {
-        return "log_id";
-    }
-
-    public getAttributeMap(): ModelAttributeMap {
-        return SmartDbLogModel.attributeMap;
-    }
-
-    get data(): string {
-        return this._data;
-    }
-
-    set data(data: string) {
-        this._data = data;
-    }
-
-    // noinspection FunctionNamingConventionJS
-    get id(): number {
-        return this._id;
-    }
-
-    // noinspection FunctionNamingConventionJS
-    set id(id: number) {
-        this._id = id;
-    }
-
-    get info(): string {
-        return this._info;
-    }
-
-    set info(info: string) {
-        this._info = info;
-    }
-
-    get location(): string {
-        return this._location;
-    }
-
-    set location(location: string) {
-        this._location = location;
-    }
-
-    // noinspection FunctionNamingConventionJS
-    get log_data(): string {
-        return this._data;
-    }
-
-    // noinspection FunctionNamingConventionJS
-    set log_data(data: string) {
-        this._data = data;
-    }
-
-    // noinspection FunctionNamingConventionJS
-    get log_id(): number {
-        return this._id;
-    }
-
-    // noinspection FunctionNamingConventionJS
-    set log_id(id: number) {
-        this._id = id;
-    }
-
-    // noinspection FunctionNamingConventionJS
-    get log_info(): string {
-        return this._info;
-    }
-
-    // noinspection FunctionNamingConventionJS
-    set log_info(info: string) {
-        this._info = info;
-    }
-
-    // noinspection FunctionNamingConventionJS
-    get log_location(): string {
-        return this._location;
-    }
-
-    // noinspection FunctionNamingConventionJS
-    set log_location(location: string) {
-        this._location = location;
-    }
-
-    // noinspection FunctionNamingConventionJS
-    get log_severity(): string {
-        return this._severity;
-    }
-
-    // noinspection FunctionNamingConventionJS
-    set log_severity(severity: string) {
-        this._severity = severity;
-    }
-
-    // noinspection FunctionNamingConventionJS
-    get log_timestamp(): Date {
-        return this._timestamp;
-    }
-
-    // noinspection FunctionNamingConventionJS
-    set log_timestamp(timestamp: Date) {
-        this._timestamp = timestamp;
-    }
-
-    // noinspection FunctionNamingConventionJS
-    get log_type(): string {
-        return this._type;
-    }
-
-    // noinspection FunctionNamingConventionJS
-    set log_type(type: string) {
-        this._type = type;
-    }
-
-    // noinspection FunctionNamingConventionJS
-    get log_user(): string {
-        return this._user;
-    }
-
-    // noinspection FunctionNamingConventionJS
-    set log_user(user: string) {
-        this._user = user;
-    }
-
-    get severity(): string {
-        return this._severity;
-    }
-
-    set severity(severity: string) {
-        this._severity = severity;
-    }
-
-    get timestamp(): Date {
-        return this._timestamp;
-    }
-
-    set timestamp(timestamp: Date) {
-        this._timestamp = timestamp;
-    }
-
-    get type(): string {
-        return this._type;
-    }
-
-    set type(type: string) {
-        this._type = type;
-    }
-
-    get user(): string {
-        return this._user;
-    }
-
-    set user(user: string) {
-        this._user = user;
-    }
-}