@egi/smart-db 2.0.3 → 2.1.0

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

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

@@ -0,0 +1,91 @@
+/* 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-api.ts

@@ -0,0 +1,15 @@
+// noinspection JSUnusedGlobalSymbols
+
+export * from "./smart-db";
+export * from "./models/abstract-model";
+export * from "./models/smart-db-core-table-model";
+export * from "./models/smart-db-dictionary";
+export * from "./models/smart-db-log-model";
+export * from "./models/smart-db-version-model";
+export * from "./models/smart-db-version-view-model";
+export * from "./models/sqlite-master-model";
+export * from "./models/sqlite-sequence-model";
+export * from "./smart-db-log";
+export * from "./smart-db-globals";
+export * from "./smart-db-interfaces";
+

package/src/smart-db-globals.ts

@@ -0,0 +1,136 @@
+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-interfaces.ts

@@ -0,0 +1,218 @@
+import {AbstractModel} from "./models/abstract-model";
+import {SmartDbDictionary} from "./models/smart-db-dictionary";
+import {SmartDbVersionViewModel} from "./models/smart-db-version-view-model";
+import {SmartDbSqlBuildData} from "./smart-db-sql-build-data";
+
+export interface SmartDbOptions {
+    module: string;
+    sqlFilesDirectory: string;
+    smartDbDictionary?: typeof SmartDbDictionary | any[];
+    skipAutoUpgrade?: boolean;
+}
+
+export interface SmartDbRunResult {
+    lastId: number;
+    changes: number;
+    affected: number;
+}
+
+export interface SmartDbTableInfo {
+    name: string;
+    fields: SmartDbFieldDescription[];
+}
+
+export interface SmartDbFieldDescription {
+    cid?: string | number;
+    name: string;
+    type: string;
+    virtual?: boolean;
+    notNull?: boolean;
+    defaultValue?: number | string | boolean;
+    isPk?: boolean;
+}
+
+export interface SmartDbSqlComparison {
+    compare: string | SqlFieldDescriptor,
+    with: string | SqlFieldDescriptor;
+    operation?: SqlOperationType;
+}
+
+export type SqlValueType = string | number | boolean | Date;
+
+export enum FieldNamingStyle { Database, TypeScript, All}
+
+export type GenericModelData = Record<string, SqlValueType>;
+
+export interface AttributeInfo {
+    attribute: string;
+    type: string;
+    alias?: string;
+    physical?: boolean;
+    virtual?: boolean;
+    alternative?: boolean;
+    typeScriptStyle?: boolean;
+}
+
+export interface ModelAttributeMap {
+    [key: string]: AttributeInfo;
+}
+
+export interface AbstractModelGlobals<T extends AbstractModel<T, D>, D extends GenericModelData> {
+    attributeMap: ModelAttributeMap;
+    getTableName: () => string;
+    from: (other: T | D) => T;
+}
+
+export interface SqlWhere {
+    or?: SqlWhere | SqlWhere[];
+    and?: SqlWhere | SqlWhere[];
+    expression?: SmartDbSqlComparison[];
+
+    [key: string]: SqlValueType | SqlValueType[] | SqlOperation | SqlWhere | SqlWhere[] | SmartDbSqlComparison[];
+}
+
+export type SqlUpdateValues = Record<string, SqlValueType>;
+export type SqlOrderBy = string | string[];
+type SqlGroupBy = string | string[];
+
+export interface SqlLimit {
+    offset?: number;
+    limit?: number;
+}
+
+export interface SectionDescription<T extends AbstractModel<T, D>, D extends GenericModelData> {
+    model: (new() => T) | string;
+    where?: SqlWhere;
+    fields?: string | SqlFieldDescriptor | (string | SqlFieldDescriptor)[] | null;
+    groupBy?: SqlGroupBy;
+    limit?: SqlLimit;
+}
+
+export interface SmartDbSqlOptions<T extends AbstractModel<T, D>, D extends GenericModelData> {
+    firstOnly?: boolean;
+    where?: SqlWhere;
+    fields?: string | SqlFieldDescriptor | (string | SqlFieldDescriptor)[] | null;
+    orderBy?: SqlOrderBy;
+    groupBy?: SqlGroupBy;
+    limit?: SqlLimit;
+    count?: boolean;
+    distinct?: boolean;
+    collapseRow?: boolean;
+    indexedBy?: string;
+    union?: SectionDescription<T, D> | SectionDescription<T, D>[];
+    minus?: SectionDescription<T, D> | SectionDescription<T, D>[];
+    intersect?: SectionDescription<T, D> | SectionDescription<T, D>[];
+}
+
+export enum SqlOperationType {
+// noinspection JSUnusedGlobalSymbols,LocalVariableNamingConventionJS
+    // eslint-disable-next-line no-shadow
+    GT = ">", GE = ">=", LT = "<", LE = "<=", EQ = "=", NE = "!=",
+    // eslint-disable-next-line no-shadow
+    IN = "IN", LIKE = "LIKE", NOT_LIKE = "NOT LIKE",
+    // eslint-disable-next-line no-shadow
+    IS_NULL = "IS NULL", IS_NOT_NULL = "IS NOT NULL",
+    // eslint-disable-next-line no-shadow
+    LITERAL = "LITERAL",
+    VALUE = "VALUE"
+}
+
+export enum SqlFieldOperationType {
+    VALUE = "VALUE",
+    FIELD = "FIELD",
+    COUNT = "COUNT",
+    COALESCE = "COALESCE"
+}
+
+export interface SqlFieldDescriptor {
+    operation: SqlFieldOperationType,
+    value: SqlFieldDescriptor | SqlValueType | (SqlFieldDescriptor | SqlValueType)[],
+    alias?: string,
+    literal?: boolean;
+}
+
+export interface SqlOperation {
+    operation: SqlOperationType;
+    value: SqlValueType | SqlValueType[];
+    key?: string;
+    literalOperation?: SqlOperationType;
+}
+
+export interface KeyValueList {
+    [key: string]: SqlValueType;
+}
+
+export interface IndexedGenericModelData<T extends AbstractModel<T, D>, D extends GenericModelData> {
+    [key: string]: T | GenericModelData;
+}
+
+export interface SmartDbSqlBuildDataResults {
+    sql: string;
+    values: SqlValueType[];
+}
+
+export interface SmartDbApi {
+    initDb(appOptions: SmartDbOptions): Promise<SmartDbVersionViewModel[]>;
+
+    exists<T extends AbstractModel<T, D>, D extends GenericModelData>(modelClass: string | (new () => T), type?: "view" | "table" | "index", indexTableName?: string): Promise<boolean>;
+
+    existsSync<T extends AbstractModel<T, D>, D extends GenericModelData>(modelClass: string | (new () => T), type?: "view" | "table" | "index", indexTableName?: string): boolean;
+
+    get<T extends AbstractModel<T, D>, D extends GenericModelData>(modelClass: string | (new () => T), options: SmartDbSqlOptions<T, D>): Promise<(T | D)[] | T | D | SqlValueType | IndexedGenericModelData<T, D> | string | string[]>;
+
+    getSync<T extends AbstractModel<T, D>, D extends GenericModelData>(modelClass: string | (new () => T), options: SmartDbSqlOptions<T, D>): (T | D)[] | T | D | IndexedGenericModelData<T, D> | SqlValueType | string[] | false;
+
+    getFirst<T extends AbstractModel<T, D>, D extends GenericModelData>(modelClass: string | (new () => T), where?: SqlWhere, fields?: string | string[] | null, orderBy?: SqlOrderBy): Promise<T>;
+
+    getFirstSync<T extends AbstractModel<T, D>, D extends GenericModelData>(modelClass: string | (new () => T), where?: SqlWhere, fields?: string | string[] | null, orderBy?: SqlOrderBy): T | false;
+
+    getAll<T extends AbstractModel<T, D>, D extends GenericModelData>(modelClass: string | (new () => T), where?: SqlWhere, fields?: string | string[] | null, orderBy?: SqlOrderBy, limit?: SqlLimit): Promise<T[]>;
+
+    getAllSync<T extends AbstractModel<T, D>, D extends GenericModelData>(modelClass: string | (new () => T), where?: SqlWhere, fields?: string | string[] | null, orderBy?: SqlOrderBy, limit?: SqlLimit): T[] | false;
+
+    delete<T extends AbstractModel<T, D>, D extends GenericModelData>(modelClass: string | (new () => T), where?: SqlWhere): Promise<number>;
+
+    deleteSync<T extends AbstractModel<T, D>, D extends GenericModelData>(modelClass: string | (new () => T), where?: SqlWhere): number | false;
+
+    update<T extends AbstractModel<T, D>, D extends GenericModelData>(modelClass: string | (new () => T), values: SqlUpdateValues | T, where?: SqlWhere): Promise<number>;
+
+    updateSync<T extends AbstractModel<T, D>, D extends GenericModelData>(modelClass: string | (new () => T), values: SqlUpdateValues | T, where?: SqlWhere): number | false;
+
+    insert<T extends AbstractModel<T, D>, D extends GenericModelData>(modelClass: string | (new () => T), values: SqlUpdateValues | T): Promise<number>;
+
+    insertSync<T extends AbstractModel<T, D>, D extends GenericModelData>(modelClass: string | (new () => T), values: SqlUpdateValues | T): number | false;
+
+    exec(script: string): Promise<void>;
+
+    execSync(script: string): SmartDbDatabase | false;
+
+    getLastError(): any;
+
+    getLastBuildData(): SmartDbSqlBuildData;
+
+    getDbQuote(): string;
+
+    getTableInfo(table: string): Promise<SmartDbTableInfo>;
+
+    toDate(d: Date | number | string): Date | null;
+
+    getDbConnector(): string | SmartDbConnector;
+
+    toDbTimestamp(d: Date | number): string;
+
+    toDbDate(d: Date | number): string;
+
+    hasConcurrentTransactions(): boolean;
+
+    closeSync(): boolean;
+
+    close(): Promise<void>;
+}
+
+export interface SmartDbDatabase {
+    // empty placeholder interface
+}
+
+export interface SmartDbConnector {
+    // empty placeholder interface
+}