@egi/smart-db 2.3.1 → 2.3.2

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/{smart-db-api.d.ts → src/smart-db-api.ts}

@@ -1,3 +1,5 @@
+// noinspection JSUnusedGlobalSymbols
+
 export * from "./smart-db";
 export * from "./models/abstract-model";
 export * from "./models/smart-db-core-table-model";
@@ -10,3 +12,4 @@ 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/{smart-db-interfaces.d.ts → src/smart-db-interfaces.ts}

@@ -1,22 +1,26 @@
-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";
+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;
@@ -26,18 +30,19 @@ export interface SmartDbFieldDescription {
     defaultValue?: number | string | boolean;
     isPk?: boolean;
 }
+
 export interface SmartDbSqlComparison {
-    compare: string | SqlFieldDescriptor;
+    compare: string | SqlFieldDescriptor,
     with: string | SqlFieldDescriptor;
     operation?: SqlOperationType;
 }
-export declare type SqlValueType = string | number | boolean | Date;
-export declare enum FieldNamingStyle {
-    Database = 0,
-    TypeScript = 1,
-    All = 2
-}
-export declare type GenericModelData = Record<string, SqlValueType>;
+
+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;
@@ -47,34 +52,42 @@ export interface AttributeInfo {
     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 declare type SqlUpdateValues = Record<string, SqlValueType>;
-export declare type SqlOrderBy = string | string[];
-declare type SqlGroupBy = string | string[];
+
+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;
+    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;
@@ -90,81 +103,116 @@ export interface SmartDbSqlOptions<T extends AbstractModel<T, D>, D extends Gene
     minus?: SectionDescription<T, D> | SectionDescription<T, D>[];
     intersect?: SectionDescription<T, D> | SectionDescription<T, D>[];
 }
-export declare enum SqlOperationType {
-    GT = ">",
-    GE = ">=",
-    LT = "<",
-    LE = "<=",
-    EQ = "=",
-    NE = "!=",
-    IN = "IN",
-    LIKE = "LIKE",
-    NOT_LIKE = "NOT LIKE",
-    IS_NULL = "IS NULL",
-    IS_NOT_NULL = "IS NOT NULL",
+
+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 declare enum SqlFieldOperationType {
+
+export enum SqlFieldOperationType {
     VALUE = "VALUE",
     FIELD = "FIELD",
     COUNT = "COUNT",
     COALESCE = "COALESCE"
 }
+
 export interface SqlFieldDescriptor {
-    operation: SqlFieldOperationType;
-    value: SqlFieldDescriptor | SqlValueType | (SqlFieldDescriptor | SqlValueType)[];
-    alias?: string;
+    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 {
-}
-export {};
+    // empty placeholder interface
+}