@egi/smart-db 2.0.4 → 2.2.0

package/{model → models}/smart-db-version-view-model.d.ts

@@ -1,6 +1,6 @@
-import { AbstractModel, GenericModel, ModelAttributeMap } from "./abstract-model";
-import { SqlValueType } from "../smart-db-interface";
-export interface SmartDbVersionViewModelData extends Record<string, any> {
+import { GenericModelData, ModelAttributeMap, SqlValueType } from "../smart-db-interfaces";
+import { AbstractModel } from "./abstract-model";
+export interface SmartDbVersionViewModelData extends GenericModelData {
     id?: number;
     module?: string;
     sequence?: number;
@@ -11,7 +11,7 @@ export interface SmartDbVersionViewModelData extends Record<string, any> {
     installDate?: Date;
     versionString?: SqlValueType;
 }
-export declare class SmartDbVersionViewModel extends AbstractModel {
+export declare class SmartDbVersionViewModel extends AbstractModel<SmartDbVersionViewModel, SmartDbVersionViewModelData> {
     private _id?;
     private _module?;
     private _sequence?;
@@ -22,49 +22,50 @@ export declare class SmartDbVersionViewModel extends AbstractModel {
     private _installDate?;
     private _versionString?;
     static readonly attributeMap: ModelAttributeMap;
+    constructor(data?: SmartDbVersionViewModel | SmartDbVersionViewModelData);
     static getClassName(): string;
     static getTableName(): string;
     static getPrimaryKey(): string;
-    static from(other: AbstractModel | GenericModel): SmartDbVersionViewModel;
-    clone(): AbstractModel;
+    static from(other: SmartDbVersionViewModel | SmartDbVersionViewModelData): SmartDbVersionViewModel;
+    clone(): SmartDbVersionViewModel;
     getClassName(): string;
     getTableName(): string;
     getPrimaryKey(): string;
     getAttributeMap(): ModelAttributeMap;
     get id(): number;
     set id(id: number);
-    get ver_id(): number;
-    set ver_id(id: number);
+    get installDate(): Date;
+    set installDate(installDate: Date);
     get module(): string;
     set module(module: string);
-    get ver_module(): string;
-    set ver_module(module: string);
+    get releaseType(): string;
+    set releaseType(releaseType: string);
+    get revision(): string;
+    set revision(revision: string);
     get sequence(): number;
     set sequence(sequence: number);
-    get ver_sequence(): number;
-    set ver_sequence(sequence: number);
-    get version(): string;
-    set version(version: string);
-    get ver_version(): string;
-    set ver_version(version: string);
     get subVersion(): string;
     set subVersion(subVersion: string);
-    get ver_sub_version(): string;
-    set ver_sub_version(subVersion: string);
-    get revision(): string;
-    set revision(revision: string);
-    get ver_revision(): string;
-    set ver_revision(revision: string);
-    get releaseType(): string;
-    set releaseType(releaseType: string);
-    get ver_release_type(): string;
-    set ver_release_type(releaseType: string);
-    get installDate(): Date;
-    set installDate(installDate: Date);
+    get ver_id(): number;
+    set ver_id(id: number);
     get ver_install_date(): Date;
     set ver_install_date(installDate: Date);
-    get versionString(): SqlValueType;
-    set versionString(versionString: SqlValueType);
+    get ver_module(): string;
+    set ver_module(module: string);
+    get ver_release_type(): string;
+    set ver_release_type(releaseType: string);
+    get ver_revision(): string;
+    set ver_revision(revision: string);
+    get ver_sequence(): number;
+    set ver_sequence(sequence: number);
+    get ver_sub_version(): string;
+    set ver_sub_version(subVersion: string);
+    get ver_version(): string;
+    set ver_version(version: string);
     get ver_version_string(): SqlValueType;
     set ver_version_string(versionString: SqlValueType);
+    get version(): string;
+    set version(version: string);
+    get versionString(): SqlValueType;
+    set versionString(versionString: SqlValueType);
 }

package/models/smart-db-version-view-model.js

@@ -0,0 +1 @@
+import{AbstractModel}from"./abstract-model";export class SmartDbVersionViewModel extends AbstractModel{constructor(e){super(),e&&this.assign(e)}static getClassName(){return"SmartDbVersionViewModel"}static getTableName(){return"smart_db_version_view"}static getPrimaryKey(){return""}static from(e){let t=null;return e&&(t=new SmartDbVersionViewModel,e instanceof SmartDbVersionViewModel?Object.assign(t,e):t.assign(e)),t}clone(){return SmartDbVersionViewModel.from(this)}getClassName(){return"SmartDbVersionViewModel"}getTableName(){return"smart_db_version_view"}getPrimaryKey(){return""}getAttributeMap(){return SmartDbVersionViewModel.attributeMap}get id(){return this._id}set id(e){this._id=e}get installDate(){return this._installDate}set installDate(e){this._installDate=e}get module(){return this._module}set module(e){this._module=e}get releaseType(){return this._releaseType}set releaseType(e){this._releaseType=e}get revision(){return this._revision}set revision(e){this._revision=e}get sequence(){return this._sequence}set sequence(e){this._sequence=e}get subVersion(){return this._subVersion}set subVersion(e){this._subVersion=e}get ver_id(){return this._id}set ver_id(e){this._id=e}get ver_install_date(){return this._installDate}set ver_install_date(e){this._installDate=e}get ver_module(){return this._module}set ver_module(e){this._module=e}get ver_release_type(){return this._releaseType}set ver_release_type(e){this._releaseType=e}get ver_revision(){return this._revision}set ver_revision(e){this._revision=e}get ver_sequence(){return this._sequence}set ver_sequence(e){this._sequence=e}get ver_sub_version(){return this._subVersion}set ver_sub_version(e){this._subVersion=e}get ver_version(){return this._version}set ver_version(e){this._version=e}get ver_version_string(){return this._versionString}set ver_version_string(e){this._versionString=e}get version(){return this._version}set version(e){this._version=e}get versionString(){return this._versionString}set versionString(e){this._versionString=e}}SmartDbVersionViewModel.attributeMap={id:{alias:"ver_id",typeScriptStyle:!0,type:"number",attribute:"_id"},ver_id:{physical:!0,type:"number",attribute:"_id"},module:{alias:"ver_module",typeScriptStyle:!0,type:"string",attribute:"_module"},ver_module:{physical:!0,type:"string",attribute:"_module"},sequence:{alias:"ver_sequence",typeScriptStyle:!0,type:"number",attribute:"_sequence"},ver_sequence:{physical:!0,type:"number",attribute:"_sequence"},version:{alias:"ver_version",typeScriptStyle:!0,type:"string",attribute:"_version"},ver_version:{physical:!0,type:"string",attribute:"_version"},subVersion:{alias:"ver_sub_version",typeScriptStyle:!0,type:"string",attribute:"_subVersion"},ver_sub_version:{physical:!0,type:"string",attribute:"_subVersion"},revision:{alias:"ver_revision",typeScriptStyle:!0,type:"string",attribute:"_revision"},ver_revision:{physical:!0,type:"string",attribute:"_revision"},releaseType:{alias:"ver_release_type",typeScriptStyle:!0,type:"string",attribute:"_releaseType"},ver_release_type:{physical:!0,type:"string",attribute:"_releaseType"},installDate:{alias:"ver_install_date",typeScriptStyle:!0,type:"Date",attribute:"_installDate"},ver_install_date:{physical:!0,type:"Date",attribute:"_installDate"},versionString:{alias:"ver_version_string",typeScriptStyle:!0,type:"SqlValueType",attribute:"_versionString"},ver_version_string:{physical:!0,type:"SqlValueType",attribute:"_versionString"}};

package/{model → models}/sqlite-master-model.d.ts

@@ -1,5 +1,12 @@
-import { AbstractModel, ModelAttributeMap } from "./abstract-model";
-export declare class SqliteMasterModel extends AbstractModel {
+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 declare class SqliteMasterModel extends AbstractModel<SqliteMasterModel, SqliteMasterModelData> {
     private _type?;
     private _name;
     private _tbl_name?;
@@ -8,22 +15,22 @@ export declare class SqliteMasterModel extends AbstractModel {
     static readonly attributeMap: ModelAttributeMap;
     static getClassName(): string;
     static getTableName(): string;
-    static from(other: any): SqliteMasterModel;
+    static from(other: SqliteMasterModel): SqliteMasterModel;
     clone(): SqliteMasterModel;
     getClassName(): string;
     getTableName(): string;
     getAttributeMap(): ModelAttributeMap;
     getPrimaryKey(): string;
-    get type(): string;
-    set type(type: string);
     get name(): string;
     set name(name: string);
-    get tbl_name(): string;
-    set tbl_name(tblNname: string);
-    get tblName(): string;
-    set tblName(tblNname: string);
     get rootpage(): number;
     set rootpage(rootpage: number);
     get sql(): string;
     set sql(sql: string);
+    get tblName(): string;
+    set tblName(tblNname: string);
+    get tbl_name(): string;
+    set tbl_name(tblNname: string);
+    get type(): string;
+    set type(type: string);
 }

package/models/sqlite-master-model.js

@@ -0,0 +1 @@
+import{AbstractModel}from"./abstract-model";export class SqliteMasterModel extends AbstractModel{static getClassName(){return"SqliteMasterModel"}static getTableName(){return"sqlite_master"}static from(t){let e=null;return t&&(e=new SqliteMasterModel,t instanceof SqliteMasterModel?Object.assign(e,t):e.assign(t)),e}clone(){return SqliteMasterModel.from(this)}getClassName(){return"SqliteMasterModel"}getTableName(){return"sqlite_master"}getAttributeMap(){return SqliteMasterModel.attributeMap}getPrimaryKey(){return"name"}get name(){return this._name}set name(t){this._name=t}get rootpage(){return this._rootpage}set rootpage(t){this._rootpage=t}get sql(){return this._sql}set sql(t){this._sql=t}get tblName(){return this._tbl_name}set tblName(t){this._tbl_name=t}get tbl_name(){return this._tbl_name}set tbl_name(t){this._tbl_name=t}get type(){return this._type}set type(t){this._type=t}}SqliteMasterModel.attributeMap={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"}};

package/{model → models}/sqlite-sequence-model.d.ts

@@ -1,18 +1,18 @@
-import { AbstractModel, GenericModel, ModelAttributeMap } from "./abstract-model";
-import { SqlValueType } from "../smart-db-interface";
+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 declare class SqliteSequenceModel extends AbstractModel {
+export declare class SqliteSequenceModel extends AbstractModel<SqliteSequenceModel, SqliteSequenceModelData> {
     private _name?;
     private _seq?;
     static readonly attributeMap: ModelAttributeMap;
     static getClassName(): string;
     static getTableName(): string;
     static getPrimaryKey(): string;
-    static from(other: AbstractModel | GenericModel): SqliteSequenceModel;
-    clone(): AbstractModel;
+    static from(other: SqliteSequenceModel | GenericModelData): SqliteSequenceModel;
+    clone(): SqliteSequenceModel;
     getClassName(): string;
     getTableName(): string;
     getPrimaryKey(): string;

package/models/sqlite-sequence-model.js

@@ -0,0 +1 @@
+import{AbstractModel}from"./abstract-model";export class SqliteSequenceModel extends AbstractModel{static getClassName(){return"SqliteSequenceModel"}static getTableName(){return"sqlite_sequence"}static getPrimaryKey(){return""}static from(e){let t=null;return e&&(t=new SqliteSequenceModel,e instanceof SqliteSequenceModel?Object.assign(t,e):t.assign(e)),t}clone(){return SqliteSequenceModel.from(this)}getClassName(){return"SqliteSequenceModel"}getTableName(){return"sqlite_sequence"}getPrimaryKey(){return""}getAttributeMap(){return SqliteSequenceModel.attributeMap}get name(){return this._name}set name(e){this._name=e}get seq(){return this._seq}set seq(e){this._seq=e}}SqliteSequenceModel.attributeMap={name:{physical:!0,typeScriptStyle:!0,type:"SqlValueType",attribute:"_name"},seq:{physical:!0,typeScriptStyle:!0,type:"SqlValueType",attribute:"_seq"}};

package/package.json

@@ -1,9 +1,20 @@
 {
   "name": "@egi/smart-db",
-  "version": "2.0.4",
+  "version": "2.2.0",
   "description": "Unified Smart DB Access",
-  "main": "dist/index.js",
+  "author": "Marcel Egloff",
   "type": "module",
+  "browser": {
+    "fs": false,
+    "path": false,
+    "os": false
+  },
+  "keywords": [
+    "MySql",
+    "Sqlite3",
+    "Smart",
+    "DB"
+  ],
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1",
     "copy-assets": "bin/copy-assets",
@@ -16,41 +27,58 @@
     "tsc-pro": "tsc --build tsconfig.pro.json",
     "tsc-watch": "tsc --build tsconfig.json --watch",
     "terser": "node dist/helpers/terser-tree 'dist/**/*.js' && rm -f dist/helpers/terser-tree.*",
-    "extract-db-interface": "bin/extract-db-interface && tsc --build tsconfig.test-model.json"
+    "extract-db-api": "bin/extract-db-api && tsc --build tsconfig.test-model.json"
+  },
+  "exports": {
+    ".": "./dist/smart-db-api.js",
+    "./drivers/smart-db-sqlite3": "./dist/drivers/smart-db-sqlite3.js",
+    "./drivers/smart-db-better-sqlite3": "./dist/drivers/smart-db-better-sqlite3.js",
+    "./drivers/smart-db-mysql": "./dist/drivers/smart-db-mysql.js",
+    "./drivers/smart-db-mysql2": "./dist/drivers/smart-db-mysql2.js"
+  },
+  "types": "./dist/smart-db-api.d.ts",
+  "typesVersions": {
+    "*": {
+      "drivers/smart-db-sqlite3": [
+        "./dist/drivers/smart-db-sqlite3.d.ts"
+      ],
+      "drivers/smart-db-better-sqlite3": [
+        "./dist/drivers/smart-db-better-sqlite3.d.ts"
+      ],
+      "drivers/smart-db-better-mysql": [
+        "./dist/drivers/smart-db-better-mysql.d.ts"
+      ],
+      "drivers/smart-db-better-mysql2": [
+        "./dist/drivers/smart-db-better-mysql2.d.ts"
+      ]
+    }
   },
   "bin": {
-    "extract-db-interface": "./bin/extract-db-interface",
-    "extract-db-interface.js": "./"
+    "extract-db-api": "bin/extract-db-api",
+    "extract-db-api.js": "./"
   },
-  "keywords": [
-    "MySql",
-    "Sqlite3",
-    "Smart",
-    "DB"
-  ],
-  "author": "Marcel Egloff",
-  "license": "UNLICENSED",
   "dependencies": {
-    "lodash": "^4.17.15",
-    "sqlite3": "^5.0.0",
+    "lodash": "^4.17.21",
+    "sqlite3": "^5.0.2",
     "terser": "^4.8.0"
   },
   "devDependencies": {
-    "@types/better-sqlite3": "^5.4.0",
-    "@types/glob": "^7.1.2",
-    "@types/lodash": "^4.14.155",
-    "@types/mysql": "^2.15.14",
-    "@types/node": "^14.0.13",
-    "@types/sqlite3": "^3.1.6",
-    "@types/uglify-js": "^3.9.2",
-    "glob": "^7.1.6",
-    "mocha": "^8.0.1",
+    "@types/better-sqlite3": "^5.4.2",
+    "@types/glob": "^7.1.3",
+    "@types/lodash": "^4.14.170",
+    "@types/mysql": "^2.15.18",
+    "@types/node": "^16.11.19",
+    "@types/sqlite3": "^3.1.7",
+    "@types/uglify-js": "^3.13.0",
+    "glob": "^7.1.7",
+    "mocha": "^8.4.0",
     "npm-run-all": "^4.1.5",
-    "uglify-js": "^3.10.0"
+    "uglify-js": "^3.13.10"
   },
   "optionalDependencies": {
     "better-sqlite3": "^7.1.0",
     "mysql": "^2.18.1",
     "mysql2": "^2.1.0"
-  }
+  },
+  "license": "UNLICENSED"
 }

package/smart-db-api.d.ts

@@ -0,0 +1,12 @@
+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/smart-db-api.js

@@ -0,0 +1 @@
+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/smart-db-globals.d.ts

@@ -0,0 +1,22 @@
+import { SqlFieldDescriptor, SqlOperation, SqlOperationType, SqlValueType } from "./smart-db-interfaces";
+export declare const OP: (op: SqlOperationType, value?: SqlValueType | SqlValueType[], key?: string, literalOp?: SqlOperationType) => SqlOperation;
+export declare const VALUE: (value: SqlValueType, alias?: string, literal?: boolean) => SqlFieldDescriptor;
+export declare const FIELD: (value: string, alias?: string) => SqlFieldDescriptor;
+export declare const COUNT: (value?: string, alias?: string) => SqlFieldDescriptor;
+export declare const COALESCE: (values: (SqlFieldDescriptor | SqlValueType)[], alias?: string) => SqlFieldDescriptor;
+export declare const NVL: (values: (SqlFieldDescriptor | SqlValueType)[], alias?: string) => SqlFieldDescriptor;
+export declare const LITERAL: (key: string, value: SqlValueType, op?: SqlOperationType) => SqlOperation;
+export declare const GT: (value: SqlValueType) => SqlOperation;
+export declare const GE: (value: SqlValueType) => SqlOperation;
+export declare const LT: (value: SqlValueType) => SqlOperation;
+export declare const LE: (value: SqlValueType) => SqlOperation;
+export declare const EQ: (value: SqlValueType) => SqlOperation;
+export declare const NE: (value: any) => SqlOperation;
+export declare const IN: (value: SqlValueType[]) => SqlOperation;
+export declare const IS_NULL: () => SqlOperation;
+export declare const IS_NOT_NULL: () => SqlOperation;
+export declare const SmartDbDateRegexp: RegExp;
+export declare const SmartDbTimestampRegexp: RegExp;
+export declare function toSmartDbDate(d: Date | number): string;
+export declare function toSmartDbTimestamp(d: Date | number): string;
+export declare function smartDbToDate(d: Date | number | string): Date | null;

package/smart-db-globals.js

@@ -0,0 +1 @@
+import _ from"lodash";import{SqlFieldOperationType,SqlOperationType}from"./smart-db-interfaces";export const OP=(e,t,o,r)=>o?{operation:e,value:t,key:o,literalOperation:r}:{operation:e,value:t};export const VALUE=(e,t,o)=>({operation:SqlFieldOperationType.VALUE,value:e,alias:t,literal:o});export const FIELD=(e,t)=>({operation:SqlFieldOperationType.FIELD,value:e,alias:t});export const COUNT=(e,t)=>({operation:SqlFieldOperationType.COUNT,value:e,alias:t});export const COALESCE=(e,t)=>({operation:SqlFieldOperationType.COALESCE,value:e,alias:t});export const NVL=(e,t)=>COALESCE(e,t);export const LITERAL=(e,t,o)=>OP(SqlOperationType.LITERAL,t,e,o||SqlOperationType.EQ);export const GT=e=>OP(SqlOperationType.GT,e);export const GE=e=>OP(SqlOperationType.GE,e);export const LT=e=>OP(SqlOperationType.LT,e);export const LE=e=>OP(SqlOperationType.LE,e);export const EQ=e=>OP(SqlOperationType.EQ,e);export const NE=e=>OP(SqlOperationType.NE,e);export const IN=e=>OP(SqlOperationType.IN,e);export const IS_NULL=()=>OP(SqlOperationType.IS_NULL);export const IS_NOT_NULL=()=>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(e){let t;return e&&(_.isNumber(e)&&(e=new Date(e)),t=e.toISOString().substr(0,19).replace("T"," ")),t}export function toSmartDbTimestamp(e){let t;return e&&(_.isNumber(e)&&(e=new Date(e)),t=e.toISOString().substr(0,23).replace("T"," ")),t}export function smartDbToDate(e){let t=null;return _.isDate(e)?t=e:(_.isNumber(e)||_.isString(e)&&(e.match(SmartDbDateRegexp)||e.match(SmartDbTimestampRegexp)))&&(t=new Date(e)),t}

package/smart-db-interfaces.d.ts

@@ -0,0 +1,170 @@
+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 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 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 declare type SqlUpdateValues = Record<string, SqlValueType>;
+export declare type SqlOrderBy = string | string[];
+declare 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 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",
+    LITERAL = "LITERAL",
+    VALUE = "VALUE"
+}
+export declare 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 {
+}
+export interface SmartDbConnector {
+}
+export {};

package/smart-db-interfaces.js

@@ -0,0 +1 @@
+export var FieldNamingStyle;!function(e){e[e.Database=0]="Database",e[e.TypeScript=1]="TypeScript",e[e.All=2]="All"}(FieldNamingStyle||(FieldNamingStyle={}));export var SqlOperationType;!function(e){e.GT=">",e.GE=">=",e.LT="<",e.LE="<=",e.EQ="=",e.NE="!=",e.IN="IN",e.LIKE="LIKE",e.NOT_LIKE="NOT LIKE",e.IS_NULL="IS NULL",e.IS_NOT_NULL="IS NOT NULL",e.LITERAL="LITERAL",e.VALUE="VALUE"}(SqlOperationType||(SqlOperationType={}));export var SqlFieldOperationType;!function(e){e.VALUE="VALUE",e.FIELD="FIELD",e.COUNT="COUNT",e.COALESCE="COALESCE"}(SqlFieldOperationType||(SqlFieldOperationType={}));

package/smart-db-log.d.ts

@@ -1,11 +1,37 @@
-import { SmartDbInterface, SeverityLevel, SeverityCode } from "./smart-db-interface";
-export declare enum SmartDbLogType {
-    Frontend = "frontend",
-    Backend = "backend",
-    Database = "database",
-    UpgradeManager = "upgrade-mananger",
-    Other = "other"
-}
+import { SmartDbApi } from "./smart-db-interfaces";
+export declare const SmartDbLogLocation: {
+    Frontend: string;
+    Backend: string;
+    Database: string;
+    UpgradeManager: string;
+    Other: string;
+};
+export declare type SmartDbLogLocationType = typeof SmartDbLogLocation;
+export declare type SmartDbLogLocationKey = keyof SmartDbLogLocationType;
+export declare type SmartDbLogLocationValue = SmartDbLogLocationType[keyof SmartDbLogLocationType];
+export declare const SeverityCode: {
+    readonly Fatal: "F";
+    readonly Error: "E";
+    readonly Warning: "W";
+    readonly Info: "I";
+    readonly Debug: "D";
+    readonly Local: "L";
+};
+export declare type SeverityCodeType = typeof SeverityCode;
+export declare type SeverityCodeKey = keyof SeverityCodeType;
+export declare type SeverityCodeValue = SeverityCodeType[keyof SeverityCodeType];
+export declare const SeverityLevel: {
+    readonly None: 0;
+    readonly Fatal: 1;
+    readonly Error: 2;
+    readonly Warning: 3;
+    readonly Info: 4;
+    readonly Debug: 5;
+    readonly All: 9;
+};
+export declare type SeverityLevelType = typeof SeverityLevel;
+export declare type SeverityLevelKey = keyof SeverityLevelType;
+export declare type SeverityLevelValue = SeverityLevelType[keyof SeverityLevelType];
 export declare class SmartDbLog {
     private db;
     private dbLogLevel;
@@ -13,20 +39,20 @@ export declare class SmartDbLog {
     private userId;
     private dbLogging;
     private isLogging;
-    constructor(db?: SmartDbInterface);
-    getConsoleLogLevel(): SeverityLevel;
-    setConsoleLogLevel(consoleLogLevel: SeverityLevel): void;
-    getDbLogLevel(): SeverityLevel;
-    setDbLogLevel(dbLogLevel: SeverityLevel): void;
-    setDb(db: SmartDbInterface): void;
+    constructor(db?: SmartDbApi);
+    getConsoleLogLevel(): SeverityLevelValue;
+    setConsoleLogLevel(consoleLogLevel: SeverityLevelValue): void;
+    getDbLogLevel(): SeverityLevelValue;
+    setDbLogLevel(dbLogLevel: SeverityLevelValue): void;
+    setDb(db: SmartDbApi): void;
     setUserId(userId: string | number): void;
     setDbLogging(dbLogging: boolean): void;
     getDbLogging(): boolean;
-    logFatal(type: SmartDbLogType, location: string, message: string | Error, data?: any): void;
-    logError(type: SmartDbLogType, location: string, message: string | Error, data?: any): void;
-    logWarning(type: SmartDbLogType, location: string, message: string | Error, data?: any): void;
-    logInfo(type: SmartDbLogType, location: string, message: string | Error, data?: any): void;
-    logDebug(type: SmartDbLogType, location: string, message: string | Error, data?: any): void;
-    writeLog(type: SmartDbLogType, location: string, severity: SeverityCode, message: string | Error, data: unknown, timestamp?: Date | string | number): void;
+    logFatal(type: SmartDbLogLocationValue, location: string, message: string | Error, data?: any): void;
+    logError(type: SmartDbLogLocationValue, location: string, message: string | Error, data?: any): void;
+    logWarning(type: SmartDbLogLocationValue, location: string, message: string | Error, data?: any): void;
+    logInfo(type: SmartDbLogLocationValue, location: string, message: string | Error, data?: any): void;
+    logDebug(type: SmartDbLogLocationValue, location: string, message: string | Error, data?: any): void;
+    writeLog(type: SmartDbLogLocationValue, location: string, severity: SeverityCodeValue, message: string | Error, data: unknown, timestamp?: Date | string | number): void;
 }
 export declare const smartDbLog: SmartDbLog;

package/smart-db-log.js

@@ -1 +1 @@
-"use strict";var __importStar=this&&this.__importStar||function(e){if(e&&e.__esModule)return e;var t={};if(null!=e)for(var r in e)Object.hasOwnProperty.call(e,r)&&(t[r]=e[r]);return t.default=e,t};Object.defineProperty(exports,"__esModule",{value:!0});var SmartDbLogType,smart_db_interface_1=require("./smart-db-interface"),smart_db_1=require("./smart-db"),smart_db_log_model_1=require("./model/smart-db-log-model"),_=__importStar(require("lodash"));!function(e){e.Frontend="frontend",e.Backend="backend",e.Database="database",e.UpgradeManager="upgrade-mananger",e.Other="other"}(SmartDbLogType=exports.SmartDbLogType||(exports.SmartDbLogType={}));var SmartDbLog=function(){function e(e){this.dbLogLevel=smart_db_interface_1.SeverityLevel.Info,this.consoleLogLevel=smart_db_interface_1.SeverityLevel.Error,this.userId=null,this.dbLogging=!1,this.isLogging=!1,this.db=e}return e.prototype.getConsoleLogLevel=function(){return this.consoleLogLevel},e.prototype.setConsoleLogLevel=function(e){this.consoleLogLevel=e},e.prototype.getDbLogLevel=function(){return this.dbLogLevel},e.prototype.setDbLogLevel=function(e){this.dbLogLevel=e},e.prototype.setDb=function(e){var t=this;this.db=e,this.db?this.db.exists(smart_db_log_model_1.SmartDbLogModel).then((function(e){t.dbLogging=e})).catch((function(e){throw e})):this.dbLogging=!1},e.prototype.setUserId=function(e){this.userId=e},e.prototype.setDbLogging=function(e){this.dbLogging=e},e.prototype.getDbLogging=function(){return this.dbLogging},e.prototype.logFatal=function(e,t,r,o){this.writeLog(e,t,smart_db_interface_1.SeverityCode.Fatal,r,o)},e.prototype.logError=function(e,t,r,o){this.writeLog(e,t,smart_db_interface_1.SeverityCode.Error,r,o)},e.prototype.logWarning=function(e,t,r,o){this.writeLog(e,t,smart_db_interface_1.SeverityCode.Warning,r,o)},e.prototype.logInfo=function(e,t,r,o){this.writeLog(e,t,smart_db_interface_1.SeverityCode.Info,r,o)},e.prototype.logDebug=function(e,t,r,o){this.writeLog(e,t,smart_db_interface_1.SeverityCode.Debug,r,o)},e.prototype.writeLog=function(e,t,r,o,i,a){var s=this;try{if(this.isLogging)console.error("recursive logging error:",e,t,r,o,i);else{this.isLogging=!0;var n,g,b=smart_db_interface_1.SeverityLevel.None;switch(r){case smart_db_interface_1.SeverityCode.Fatal:n=console.error,b=smart_db_interface_1.SeverityLevel.Fatal;break;case smart_db_interface_1.SeverityCode.Error:n=console.error,b=smart_db_interface_1.SeverityLevel.Error;break;case smart_db_interface_1.SeverityCode.Warning:n=console.warn,b=smart_db_interface_1.SeverityLevel.Warning;break;case smart_db_interface_1.SeverityCode.Info:n=console.info,b=smart_db_interface_1.SeverityLevel.Info;break;case smart_db_interface_1.SeverityCode.Debug:n=console.debug,b=smart_db_interface_1.SeverityLevel.Debug}if(_.isString(a)){var l=a.match(smart_db_1.SmartDb.DbTimestampRegexp),d=l&&a.match(smart_db_1.SmartDb.DbDateRegexp);g=l?l[1]:d?d[1]+".000":smart_db_1.SmartDb.toDbTimestamp(new Date)}else g=_.isDate(a)?smart_db_1.SmartDb.toDbTimestamp(a):_.isNumber(a)?smart_db_1.SmartDb.toDbTimestamp(new Date(a)):smart_db_1.SmartDb.toDbTimestamp(new Date);if(_.isObjectLike(o))if(o instanceof Error)i||(i=o),o=o.message;else try{o=JSON.stringify(o)}catch(e){o=o.toString()}if(i){if(i instanceof Error)i=i.stack;else if(_.isObject(i))try{i=JSON.stringify(i)}catch(e){i=i.toString(),this.db&&this.dbLogLevel>=b&&console.error("unable to stringify log data",i)}else i.toString?i=i.toString():(i=null,this.db&&this.dbLogLevel>=b&&console.error("unable to store log data",i));i&&(o+=" ("+i+")")}if(this.consoleLogLevel>=b){var c=e.substr(0,1).toUpperCase();e==SmartDbLogType.Database&&this.db&&n(r+"-"+c+"-"+g+": last statement:",this.db.getLastBuildData()),n(r+"-"+c+"-"+g+": "+o)}if(this.dbLogging&&this.dbLogLevel>=b)try{e==SmartDbLogType.Database&&(i||(i=JSON.stringify(this.db.getLastBuildData()))),this.db.insert(smart_db_log_model_1.SmartDbLogModel,{severity:r,type:e,location:t,info:o,data:i,user:this.userId,timestamp:new Date(g)}).catch((function(e){console.error("F-B-"+g+": unable to write the log statement below to database",e);try{n("F-B-"+g+": last statement:",s.db.getLastBuildData())}catch(e){n("F-B-"+g+": last statement not available")}}))}catch(e){console.error("unable to write to log",e)}}this.isLogging=!1}catch(e){this.isLogging=!1,console.error("fatal logging error",e)}},e}();exports.SmartDbLog=SmartDbLog,exports.smartDbLog=new SmartDbLog;
+import _ from"lodash";import{SmartDbLogModel}from"./models/smart-db-log-model";import{SmartDbDateRegexp,SmartDbTimestampRegexp,toSmartDbTimestamp}from"./smart-db-globals";export const SmartDbLogLocation={Frontend:"frontend",Backend:"backend",Database:"database",UpgradeManager:"upgrade-manager",Other:"other"};export const SeverityCode={Fatal:"F",Error:"E",Warning:"W",Info:"I",Debug:"D",Local:"L"};export const SeverityLevel={None:0,Fatal:1,Error:2,Warning:3,Info:4,Debug:5,All:9};export class SmartDbLog{constructor(e){this.userId=null,this.dbLogging=!0,this.isLogging=!1,this.db=e,this.dbLogLevel=SeverityLevel.Info,this.consoleLogLevel=SeverityLevel.Info}getConsoleLogLevel(){return this.consoleLogLevel}setConsoleLogLevel(e){this.consoleLogLevel=e}getDbLogLevel(){return this.dbLogLevel}setDbLogLevel(e){this.dbLogLevel=e}setDb(e){this.db=e,this.db?this.db.exists(SmartDbLogModel).then(e=>{this.dbLogging=e}).catch(e=>{throw e}):this.dbLogging=!1}setUserId(e){this.userId=e}setDbLogging(e){this.dbLogging=e}getDbLogging(){return this.dbLogging}logFatal(e,t,o,r){this.writeLog(e,t,SeverityCode.Fatal,o,r)}logError(e,t,o,r){this.writeLog(e,t,SeverityCode.Error,o,r)}logWarning(e,t,o,r){this.writeLog(e,t,SeverityCode.Warning,o,r)}logInfo(e,t,o,r){this.writeLog(e,t,SeverityCode.Info,o,r)}logDebug(e,t,o,r){this.writeLog(e,t,SeverityCode.Debug,o,r)}writeLog(e,t,o,r,i,s){try{if(this.isLogging)console.error("recursive logging error:",e,t,o,r,i);else{this.isLogging=!0;let a,g,n=SeverityLevel.None;switch(o){case SeverityCode.Fatal:a=console.error,n=SeverityLevel.Fatal;break;case SeverityCode.Error:a=console.error,n=SeverityLevel.Error;break;case SeverityCode.Warning:a=console.warn,n=SeverityLevel.Warning;break;case SeverityCode.Info:a=console.info,n=SeverityLevel.Info;break;case SeverityCode.Debug:a=console.debug,n=SeverityLevel.Debug}if(_.isString(s)){const e=s.match(SmartDbTimestampRegexp),t=e&&s.match(SmartDbDateRegexp);g=e?e[1]:t?t[1]+".000":toSmartDbTimestamp(new Date)}else g=_.isDate(s)?toSmartDbTimestamp(s):_.isNumber(s)?toSmartDbTimestamp(new Date(s)):toSmartDbTimestamp(new Date);if(_.isObjectLike(r))if(r instanceof Error)i||(i=r),r=r.message;else try{r=JSON.stringify(r)}catch(e){r=r.toString()}else"boolean"==typeof r&&(r=r?"<true>":"<false>");if(i){if(i instanceof Error)i=i.stack;else if(_.isObject(i))try{i=JSON.stringify(i)}catch(e){i=i.toString(),this.db&&this.dbLogLevel>=n&&console.error("unable to stringify log data",i)}else i.toString?i=i.toString():(i=null,this.db&&this.dbLogLevel>=n&&console.error("unable to store log data",i));i&&(r+=` (${i})`)}if(this.consoleLogLevel>=n){const s=e.substr(0,1).toUpperCase();if(e==SmartDbLogLocation.Database&&this.db&&a(`${o}-${s}-${g}: last statement:`,this.db.getLastBuildData()),a(`${o}-${s}-${g}: ${r}`),this.dbLogging)try{e==SmartDbLogLocation.Database&&(i||(i=JSON.stringify(this.db.getLastBuildData()))),this.db.insertSync(SmartDbLogModel,{severity:o,type:e,location:t,info:r||"<empty>",data:i,user:this.userId,timestamp:new Date(g)})}catch(e){console.error(`F-B-${g}: unable to write the log statement below to database`,e,e.code,e.name,e.message);try{a(`F-B-${g}: last statement:`,this.db.getLastBuildData())}catch{a(`F-B-${g}: last statement not available`)}}}}this.isLogging=!1}catch(e){this.isLogging=!1,console.error("fatal logging error",e)}}}export const smartDbLog=new SmartDbLog;

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

@@ -0,0 +1,9 @@
+import { SmartDbSqlBuildDataResults, SqlValueType } from "./smart-db-interfaces";
+export declare class SmartDbSqlBuildData {
+    sql: string;
+    values: SqlValueType[];
+    constructor(sql?: string, values?: SqlValueType[]);
+    append(data: SmartDbSqlBuildData): void;
+    toString(): string;
+    results(): SmartDbSqlBuildDataResults;
+}

package/smart-db-sql-build-data.js

@@ -0,0 +1 @@
+import _ from"lodash";export class SmartDbSqlBuildData{constructor(s,t){this.sql=s||"",this.values=t||[]}append(s){this.sql=this.sql.trim()+" "+s.sql.trim(),this.values=_.concat(this.values,s.values)}toString(){return this.sql+" <= ("+this.values.join(", ")+")"}results(){return{sql:this.sql,values:this.values}}}