@egi/smart-db 2.3.0 → 2.3.2

package/test/test.js

@@ -0,0 +1,273 @@
+const {SmartDbMysql} = require("../dist/drivers/smart-db-mysql");
+const {SmartDbSqlite3} = require("../dist/drivers/smart-db-sqlite3");
+const {SmartDbBetterSqlite3} = require("../dist/drivers/smart-db-better-sqlite3");
+const {SmartDbDictionary} = require("./model/smart-db-dictionary");
+
+const {COUNT, COALESCE, FIELD, VALUE} = require("../dist/smart-db-interface");
+
+const assert = require("assert");
+const {describe, it, done, before, after} = require("mocha");
+const {TestTableModel} = require("./model/test-table-model");
+const fs = require("fs");
+const _ = require("lodash");
+
+const LEARN = true;
+const engineTestConfigFile = "test/data/sql-engine-tests.json";
+
+let engineTestConfig;
+try {
+    if (fs.existsSync(engineTestConfigFile)) {
+        engineTestConfig = JSON.parse(fs.readFileSync(engineTestConfigFile).toString());
+    } else {
+        engineTestConfig = null;
+    }
+} catch (err) {
+    console.error("Unable to parse engine test configuration file");
+    console.error(err);
+    engineTestConfig = null;
+}
+
+function verify(buildData, dbType, testId) {
+    const testData = buildData.results();
+
+    if (LEARN && !engineTestConfig.results) {
+        engineTestConfig.results = {};
+    }
+
+    if (LEARN && !engineTestConfig.results[testId]) {
+        engineTestConfig.results[testId] = {};
+    }
+
+    if (LEARN || !engineTestConfig.results[testId][dbType]) {
+        engineTestConfig.results[testId][dbType] = testData;
+    } else {
+        assert(_.isEqual(testData, engineTestConfig.results[testId][dbType]), JSON.stringify({
+            id: testId,
+            expected: engineTestConfig.results[testId][dbType],
+            actual: testData
+        }, null, 2));
+    }
+}
+
+describe("Databases Setup", () => {
+    if (fs.existsSync("test/db/sqlite3.db")) {
+        fs.unlinkSync("test/db/sqlite3.db");
+    }
+
+    it("should return Sqlite3 DB handle for asynchronous tests", () => {
+        let db = new SmartDbSqlite3("test/db/sqlite3.db");
+        assert(!!db);
+
+        genericTests(db, "sqlite3", {
+            module: "smart-db-test",
+            sqlFilesDirectory: "test/db/sqlite3",
+            smartDbDictionary: SmartDbDictionary
+
+        });
+
+        sqlEngineTests(db, "sqlite3");
+    });
+
+    if (fs.existsSync("test/db/better-sqlite3.db")) {
+        fs.unlinkSync("test/db/better-sqlite3.db");
+    }
+
+    it("should return Better Sqlite3 DB handle for asynchronous tests", () => {
+        let db = new SmartDbBetterSqlite3("test/db/better-sqlite3.db");
+        assert(!!db);
+
+        genericTests(db, "better-sqlite3", {
+            module: "smart-db-test",
+            sqlFilesDirectory: "test/db/sqlite3",
+            smartDbDictionary: SmartDbDictionary
+        });
+    });
+
+    if (fs.existsSync("test/db/better-sqlite3-sync.db")) {
+        fs.unlinkSync("test/db/better-sqlite3-sync.db");
+    }
+
+    it("should return Better Sqlite3 DB handle for synchronous tests", () => {
+        let db = new SmartDbBetterSqlite3("test/db/better-sqlite3-sync.db");
+        assert(!!db);
+
+        genericSyncTests(db, "better-sqlite3", {
+            module: "smart-db-test",
+            sqlFilesDirectory: "test/db/sqlite3",
+            smartDbDictionary: SmartDbDictionary
+        });
+
+        sqlEngineTests(db, "better-sqlite3");
+    });
+
+    let mysqlDb;
+    it("should return Mysql DB handle", () => {
+        mysqlDb = new SmartDbMysql({
+            host: "localhost",
+            user: "root",
+            password: "foobar",
+            multipleStatements: true
+        });
+
+        assert(!!mysqlDb);
+    });
+
+    it("should cleanup previous test schema", () => {
+        return mysqlDb.exec("drop schema if exists `smart-db-test`");
+    });
+
+    it("should create test schema", () => {
+        return mysqlDb.exec("create schema `smart-db-test`");
+    });
+
+    it("should select test schema", () => {
+        return mysqlDb.exec("use `smart-db-test`").then(() => {
+            genericTests(mysqlDb, "mysql", {
+                module: "smart-db-test",
+                sqlFilesDirectory: "test/db/mysql",
+                smartDbDictionary: SmartDbDictionary
+            });
+
+            sqlEngineTests(mysqlDb, "mysql");
+        });
+    });
+});
+
+function genericTests(db, dbType, initOptions) {
+    describe("Common Asynchronous Tests for " + dbType, () => {
+        let moduleVersions;
+        let id1;
+
+        it("should run init script", () => {
+            return db.initDb(initOptions).then((versions) => {
+                moduleVersions = versions;
+            });
+        });
+
+        it("should contain module 'smart-db-core'", () => {
+            const hasCore = moduleVersions.find((version) => {
+                return version.module == "smart-db-core";
+            });
+
+            assert(!!hasCore);
+        });
+
+        it("should contain module 'smart-db-test'", () => {
+            const hasTest = moduleVersions.find((version) => {
+                return version.module == "smart-db-core";
+            });
+
+            assert(!!hasTest);
+        });
+
+        it("should insert value", () => {
+            return db.insert(TestTableModel, {
+                string: "test-string",
+                number: 42,
+                date: new Date(),
+                boolean: true
+            }).then((id) => {
+                id1 = id;
+                assert(id1 !== false, db.getLastError());
+                assert(id1 > 0, db.getLastBuildData().toString());
+            });
+        });
+
+        it("should select row", () => {
+            return db.getFirst(TestTableModel, {
+                id: id1
+            }).then((row) => {
+                assert(row !== false, db.getLastError());
+                assert(!!row, db.getLastBuildData().toString());
+                assert(typeof row.string == "string", "string type " + (typeof row.string));
+                assert(typeof row.number == "number", "number type " + (typeof row.number));
+                assert(typeof row.date == "object", "date type " + (typeof row.date));
+                assert(typeof row.boolean == "boolean", "boolean type " + (typeof row.boolean));
+            });
+        });
+
+        it("should truncate table", () => {
+            return db.delete(TestTableModel).then((n) => {
+                assert(n !== false, db.getLastError());
+                assert(n >= 0, db.getLastBuildData().toString());
+            });
+        });
+    });
+}
+
+
+function genericSyncTests(db, dbType, initOptions) {
+    describe("Common Synchronous Tests for " + dbType, () => {
+        let moduleVersions;
+        let id1;
+
+        it("should run init script", () => {
+            return db.initDb(initOptions).then((versions) => {
+                moduleVersions = versions;
+            });
+        });
+
+        it("should contain module 'smart-db-core'", () => {
+            const hasCore = moduleVersions.find((version) => {
+                return version.module == "smart-db-core";
+            });
+
+            assert(!!hasCore);
+        });
+
+        it("should contain module 'smart-db-test'", () => {
+            const hasTest = moduleVersions.find((version) => {
+                return version.module == "smart-db-core";
+            });
+
+            assert(!!hasTest);
+        });
+
+        it("should insert value", () => {
+            id1 = db.insertSync(TestTableModel, {
+                string: "test-string",
+                number: 42,
+                date: new Date(),
+                boolean: true
+            });
+            assert(id1 !== false, db.getLastError());
+            assert(id1 > 0, db.getLastBuildData().toString());
+        });
+
+        it("should select row", () => {
+            let row = db.getFirstSync(TestTableModel, {
+                id: id1
+            });
+
+            assert(row !== false, db.getLastError());
+            assert(!!row, db.getLastBuildData().toString());
+            assert(typeof row.string == "string", "string type " + (typeof row.string));
+            assert(typeof row.number == "number", "number type " + (typeof row.number));
+            assert(typeof row.date == "object", "date type " + (typeof row.date));
+            assert(typeof row.boolean == "boolean", "boolean type " + (typeof row.boolean));
+        });
+
+        it("should truncate table", () => {
+            let n = db.deleteSync(TestTableModel);
+            assert(n !== false, db.getLastError());
+            assert(n >= 0, db.getLastBuildData().toString());
+        });
+    });
+}
+
+function sqlEngineTests(db, dbType) {
+    if (engineTestConfig && engineTestConfig.tests) {
+        describe("SQL Engine Tests for " + dbType, () => {
+            _.forEach(engineTestConfig.tests, (testData, testId) => {
+                it("should perform test: " + testId, () => {
+                    let buildData = db.buildSelectStatement(testData.table, testData.query);
+                    verify(buildData, dbType, testId);
+                });
+            });
+
+            it("finalize SQL engine results", () => {
+                fs.writeFileSync(engineTestConfigFile, JSON.stringify(engineTestConfig, null, 2));
+            });
+        });
+    }
+}

package/test/test2.js

@@ -0,0 +1,252 @@
+const {SmartDbMysql} = require("../dist/drivers/smart-db-mysql");
+const {SmartDbBetterSqlite3} = require("../dist/drivers/smart-db-better-sqlite3");
+const {smartDbLog} = require("../dist");
+
+const {COUNT, COALESCE, FIELD, VALUE} = require("../dist/smart-db-interface");
+
+const assert = require("assert");
+const {describe, it, done, before, after} = require("mocha");
+const {TestTableModel} = require("./model/test-table-model");
+const fs = require("fs");
+
+describe("Databases Setup", () => {
+    if (fs.existsSync("test/test.sqlite3")) {
+        fs.unlinkSync("test/test.sqlite3");
+    }
+
+    it("should return Sqlite3 DB handle for asynchronous tests", () => {
+        let db = new SmartDbBetterSqlite3("test/test.sqlite3");
+        assert(!!db);
+
+        genericTests(db, "sqlite3", {
+            module: "smart-db-test",
+            sqlFilesDirectory: "test/sqlite3"
+        });
+    });
+
+    it("should return Sqlite3 DB handle for synchronous tests", () => {
+        let db = new SmartDbBetterSqlite3("test/test-sync.sqlite3");
+        assert(!!db);
+
+        genericSyncTests(db, "sqlite3", {
+            module: "smart-db-test",
+            sqlFilesDirectory: "test/sqlite3"
+        });
+    });
+
+    let mysqlDb;
+    it("should return Mysql DB handle", () => {
+        let db = new SmartDbMysql({
+            host: "localhost",
+            user: "root",
+            password: "foobar",
+            multipleStatements: true
+        });
+
+        assert(!!db);
+    });
+
+    it("should cleanup previous test schema", () => {
+        return mysqlDb.exec("drop schema if exists `smart-db-test`");
+    });
+
+    it("should create test schema", () => {
+        return mysqlDb.exec("create schema `smart-db-test`");
+    });
+
+    it("should select test schema", () => {
+        return mysqlDb.exec("use `smart-db-test`").then(() => {
+            genericTests(mysqlDb, "mysql", {
+                module: "smart-db-test",
+                sqlFilesDirectory: "test/mysql"
+            });
+        });
+    });
+});
+
+
+function genericTests(db, dbType, initOptions) {
+    describe("Common Asynchronous Tests for " + dbType, () => {
+        let moduleVersions;
+        let id1;
+
+        it("should run init script", () => {
+            return db.initDb(initOptions).then((versions) => {
+                moduleVersions = versions;
+            });
+        });
+
+        it("should contain module 'smart-db-core'", () => {
+            const hasCore = moduleVersions.find((version) => {
+                return version.module == "smart-db-core";
+            });
+
+            assert(!!hasCore);
+        });
+
+        it("should contain module 'smart-db-test'", () => {
+            const hasTest = moduleVersions.find((version) => {
+                return version.module == "smart-db-core";
+            });
+
+            assert(!!hasTest);
+        });
+
+        it("should insert value", () => {
+            return db.insert(TestTableModel, {
+                string: "test-string",
+                number: 42,
+                date: new Date(),
+                boolean: true
+            }).then((id) => {
+                id1 = id;
+                assert(id1 !== false, db.getLastError());
+                assert(id1 > 0, db.getLastBuildData().toString());
+            });
+        });
+
+        it("show generate correct SQL", () => {
+            return db.getFirst(TestTableModel, {
+                expression: [{
+                    compare: "number",
+                    with: 42
+                }, {
+                    compare: "number",
+                    with: 21
+                }],
+                or: {
+                    number: 22,
+                    expression: [{
+                        compare: "number",
+                        with: 42
+                    }, {
+                        compare: "string",
+                        with: VALUE("ss")
+                    }]
+                }
+            }, [
+                "number",
+                FIELD("boolean", "t1"),
+                VALUE("ss", "test"),
+                COUNT("*", "bla"),
+                COALESCE(["number", 43], "xset")
+            ]).then((row) => {
+                console.log(db.getLastBuildData());
+            });
+        });
+
+        it("should select row", () => {
+            return db.getFirst(TestTableModel, {
+                id: id1
+            }).then((row) => {
+                assert(row !== false, db.getLastError());
+                assert(!!row, db.getLastBuildData().toString());
+                assert(typeof row.string == "string", "string type " + (typeof row.string));
+                assert(typeof row.number == "number", "number type " + (typeof row.number));
+                assert(typeof row.date == "object", "date type " + (typeof row.date));
+                assert(typeof row.boolean == "boolean", "boolean type " + (typeof row.boolean));
+            });
+        });
+
+        it("should truncate table", () => {
+            return db.delete(TestTableModel).then((n) => {
+                assert(n !== false, db.getLastError());
+                assert(n >= 0, db.getLastBuildData().toString());
+            });
+        });
+    });
+}
+
+
+function genericSyncTests(db, dbType, initOptions) {
+    describe("Common Synchronous Tests for " + dbType, () => {
+        let moduleVersions;
+        let id1;
+
+        it("should run init script", () => {
+            return db.initDb(initOptions).then((versions) => {
+                moduleVersions = versions;
+            });
+        });
+
+        it("should contain module 'smart-db-core'", () => {
+            const hasCore = moduleVersions.find((version) => {
+                return version.module == "smart-db-core";
+            });
+
+            assert(!!hasCore);
+        });
+
+        it("should contain module 'smart-db-test'", () => {
+            const hasTest = moduleVersions.find((version) => {
+                return version.module == "smart-db-core";
+            });
+
+            assert(!!hasTest);
+        });
+
+        it("should insert value", () => {
+            return db.insertSync(TestTableModel, {
+                string: "test-string",
+                number: 42,
+                date: new Date(),
+                boolean: true
+            }).then((id) => {
+                id1 = id;
+                assert(id1 !== false, db.getLastError());
+                assert(id1 > 0, db.getLastBuildData().toString());
+            });
+        });
+
+        it("show generate correct SQL", () => {
+            return db.getFirst(TestTableModel, {
+                expression: [{
+                    compare: "number",
+                    with: 42
+                }, {
+                    compare: "number",
+                    with: 21
+                }],
+                or: {
+                    number: 22,
+                    expression: [{
+                        compare: "number",
+                        with: 42
+                    }, {
+                        compare: "string",
+                        with: VALUE("ss")
+                    }]
+                }
+            }, [
+                "number",
+                FIELD("boolean", "t1"),
+                VALUE("ss", "test"),
+                COUNT("*", "bla"),
+                COALESCE(["number", 43], "xset")
+            ]).then((row) => {
+                console.log(db.getLastBuildData());
+            });
+        });
+
+        it("should select row", () => {
+            return db.getFirst(TestTableModel, {
+                id: id1
+            }).then((row) => {
+                assert(row !== false, db.getLastError());
+                assert(!!row, db.getLastBuildData().toString());
+                assert(typeof row.string == "string", "string type " + (typeof row.string));
+                assert(typeof row.number == "number", "number type " + (typeof row.number));
+                assert(typeof row.date == "object", "date type " + (typeof row.date));
+                assert(typeof row.boolean == "boolean", "boolean type " + (typeof row.boolean));
+            });
+        });
+
+        it("should truncate table", () => {
+            return db.delete(TestTableModel).then((n) => {
+                assert(n !== false, db.getLastError());
+                assert(n >= 0, db.getLastBuildData().toString());
+            });
+        });
+    });
+}
+

package/tsconfig.json

@@ -0,0 +1,32 @@
+{
+  "compileOnSave": false,
+  "compilerOptions": {
+    "baseUrl": ".",
+    "outDir": "dist",
+    "sourceMap": true,
+    "declaration": true,
+    "downlevelIteration": true,
+    "experimentalDecorators": true,
+    "moduleResolution": "node",
+    "module": "ES2020",
+    "inlineSources": true,
+    //"importHelpers": true,
+    "target": "ES2020",
+    "allowSyntheticDefaultImports": true,
+    //"esModuleInterop": true,
+    "lib": [
+      "es6",
+      "ES2020",
+      "dom"
+    ],
+    "paths": {
+      "*": [
+        "node_modules/*"
+      ]
+    }
+  },
+  "include": [
+    "src/*.ts",
+    "src/**/*.ts"
+  ]
+}

package/tsconfig.pro.json

@@ -0,0 +1,32 @@
+{
+  "compileOnSave": false,
+  "compilerOptions": {
+    "baseUrl": ".",
+    "outDir": "dist",
+    "sourceMap": false,
+    "declaration": true,
+    "downlevelIteration": true,
+    "experimentalDecorators": true,
+    "moduleResolution": "node",
+    "module": "ES2020",
+    "inlineSources": false,
+    //"importHelpers": true,
+    "target": "ES2020",
+    "allowSyntheticDefaultImports": true,
+    //"esModuleInterop": true,
+    "lib": [
+      "es6",
+      "ES2020",
+      "dom"
+    ],
+    "paths": {
+      "*": [
+        "node_modules/*"
+      ]
+    }
+  },
+  "include": [
+    "src/*.ts",
+    "src/**/*.ts"
+  ]
+}

package/tsconfig.test-model.json

@@ -0,0 +1,23 @@
+{
+  "compileOnSave": false,
+  "compilerOptions": {
+    "module": "commonjs",
+    "esModuleInterop": true,
+    "target": "es5",
+    "noImplicitAny": true,
+    "moduleResolution": "node",
+    "declaration": true,
+    "sourceMap": true,
+    "baseUrl": ".",
+    "allowSyntheticDefaultImports": true,
+    "paths": {
+      "*": [
+        "node_modules/*"
+      ]
+    }
+  },
+  "include": [
+    "test/model/*.ts"
+  ]
+}
+

package/drivers/smart-db-better-sqlite3.d.ts

@@ -1,36 +0,0 @@
-import BetterSqlite3 from "better-sqlite3";
-import { SmartDbSqlBuildData } from "../smart-db-sql-build-data";
-import { AbstractModel } from "../models/abstract-model";
-import { SmartDb } from "../smart-db";
-import { GenericModelData, SmartDbConnector, SmartDbRunResult, SmartDbTableInfo } from "../smart-db-interfaces";
-declare type VariableArgFunction = (...params: any[]) => any;
-export declare class SmartDbBetterSqlite3 extends SmartDb {
-    protected db: BetterSqlite3.Database;
-    constructor(connectorOrDb: string | BetterSqlite3.Database, options?: BetterSqlite3.Options);
-    getDatabaseType(): string;
-    getDbQuote(): string;
-    getDbConnector(): string | SmartDbConnector;
-    hasConcurrentTransactions(): boolean;
-    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;
-    exec(script: string): Promise<any>;
-    execSync(script: string): BetterSqlite3.Database | false;
-    transaction<F extends VariableArgFunction>(fn: F): BetterSqlite3.Transaction | false;
-    pragma(source: string, options?: BetterSqlite3.PragmaOptions): unknown;
-    checkpoint(databaseName?: string): BetterSqlite3.Database | false;
-    func(name: string, options: BetterSqlite3.RegistrationOptions, cb: VariableArgFunction): BetterSqlite3.Database | false;
-    aggregate(name: string, options: BetterSqlite3.AggregateOptions): BetterSqlite3.Database | false;
-    loadExtension(path: string): BetterSqlite3.Database | false;
-    closeSync(): boolean;
-    defaultSafeIntegers(toggleState?: boolean): BetterSqlite3.Database | false;
-    backup(destinationFile: string, options?: BetterSqlite3.BackupOptions): Promise<BetterSqlite3.BackupMetadata> | false;
-    getTableInfo(tableName: string): Promise<SmartDbTableInfo>;
-    protected statementRun(buildData: SmartDbSqlBuildData, retry?: number): Promise<SmartDbRunResult>;
-    protected statementRunSync(buildData: SmartDbSqlBuildData): SmartDbRunResult;
-    protected statementGet(buildData: SmartDbSqlBuildData): Promise<any>;
-    protected statementGetSync(buildData: SmartDbSqlBuildData): any;
-    protected statementGetAll(buildData: SmartDbSqlBuildData): Promise<any[]>;
-    protected statementGetAllSync(buildData: SmartDbSqlBuildData): any[];
-    close(): Promise<void>;
-}
-export {};

package/drivers/smart-db-better-sqlite3.js

@@ -1 +0,0 @@
-import BetterSqlite3 from"better-sqlite3";import _ from"lodash";import{SqliteMasterModel}from"../models/sqlite-master-model";import{SmartDb}from"../smart-db";export class SmartDbBetterSqlite3 extends SmartDb{constructor(t,e){_.isString(t)?(super(t),this.db=new BetterSqlite3(t,e)):(super(null),this.db=t,this.db.inTransaction)}getDatabaseType(){return"sqlite3"}getDbQuote(){return'"'}getDbConnector(){return this.dbConnector}hasConcurrentTransactions(){return!1}exists(t,e,s){return new Promise((r,n)=>{const a=_.isString(t)?t:t.getTableName();this.getFirst(SqliteMasterModel,{name:a,type:e,tblName:s}).then(t=>{null===t?n(this.getLastError()):r(!!t)}).catch(t=>{n(t)})})}existsSync(t,e,s){let r=!1;const n=_.isString(t)?t:t.getTableName(),a=this.getFirstSync(SqliteMasterModel,{name:n,type:e,tblName:s});if(!1===a)throw this.getLastError();return r=!!a,r}exec(t){return new Promise((e,s)=>{const r=this.execSync(t);!1===r?s("unable to execute script"):e(r)})}execSync(t){return this.saveExecute(()=>this.db.exec(t))}transaction(t){return this.saveExecute(()=>this.db.transaction(t))}pragma(t,e){return this.saveExecute(()=>this.db.pragma(t,e))}checkpoint(t){return this.saveExecute(()=>this.db.checkpoint(t))}func(t,e,s){return this.saveExecute(()=>{let r;return r=_.isFunction(e)?this.db.function(t,e):this.db.function(t,e,s),r})}aggregate(t,e){return this.saveExecute(()=>this.db.aggregate(t,e))}loadExtension(t){return this.saveExecute(()=>this.db.loadExtension(t))}closeSync(){return this.saveExecute(()=>(this.smartDbLog.setDb(null),!!this.db.close()))}defaultSafeIntegers(t){return this.saveExecute(()=>this.db.defaultSafeIntegers(t))}backup(t,e){return this.saveExecute(()=>this.db.backup(t,e))}getTableInfo(t){return new Promise(e=>{const s=this.pragma(`table_info(${t})`);let r=[];s&&(r=s.map(t=>({cid:t.cid,name:t.name,type:t.type,notNull:0!==t.notnull,defaultValue:t.dflt_value,isPk:0!==t.pk})),e({name:t,fields:r}))})}statementRun(t,e=0){return new Promise((s,r)=>{try{s(this.statementRunSync(t))}catch(n){"SQLITE_BUSY"==n.code&&e<10?setTimeout(()=>{this.statementRun(t,e+1).then(t=>{s(t)}).catch(t=>{r(t)})},100):r(n)}})}statementRunSync(t){const e=this.db.prepare(t.sql),s=e&&e.run(t.values);return s&&{changes:s.changes,affected:s.changes,lastId:s.lastInsertRowid}}statementGet(t){return new Promise((e,s)=>{try{e(this.db.prepare(t.sql).get(t.values))}catch(t){s(t)}})}statementGetSync(t){const e=this.db.prepare(t.sql);return e&&e.get(t.values)}statementGetAll(t){return new Promise((e,s)=>{try{e(this.db.prepare(t.sql).all(t.values))}catch(t){s(t)}})}statementGetAllSync(t){const e=this.db.prepare(t.sql);return e&&e.all(t.values)}close(){return new Promise((t,e)=>{try{this.smartDbLog.setDb(null),this.db.close(),t()}catch(t){e(t)}})}}

package/drivers/smart-db-mysql.d.ts

@@ -1,26 +0,0 @@
-import Mysql, { Connection, ConnectionConfig } from "mysql";
-import { SmartDbSqlBuildData } from "../smart-db-sql-build-data";
-import { AbstractModel } from "../models/abstract-model";
-import { SmartDb } from "../smart-db";
-import { GenericModelData, SmartDbRunResult, SmartDbTableInfo } from "../smart-db-interfaces";
-export declare class SmartDbMysql extends SmartDb {
-    protected db: Mysql.Connection;
-    constructor(connectorOrDb: string | ConnectionConfig | Connection);
-    getDatabaseType(): string;
-    getDbConnector(): string | Mysql.ConnectionConfig;
-    getDbQuote(): string;
-    hasConcurrentTransactions(): boolean;
-    closeSync(): boolean;
-    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;
-    exec(script: string): Promise<void>;
-    execSync(script: string): boolean;
-    getTableInfo(table: string): Promise<SmartDbTableInfo>;
-    protected statementGet(buildData: SmartDbSqlBuildData): Promise<any>;
-    protected statementGetSync(buildData: SmartDbSqlBuildData): any;
-    protected statementGetAll(buildData: SmartDbSqlBuildData): Promise<any[]>;
-    protected statementGetAllSync(buildData: SmartDbSqlBuildData): any[];
-    protected statementRun(buildData: SmartDbSqlBuildData): Promise<SmartDbRunResult>;
-    protected statementRunSync(buildData: SmartDbSqlBuildData): SmartDbRunResult;
-    close(): Promise<void>;
-}