@egi/smart-db 2.0.3 → 2.1.0

package/.eslintrc.json

@@ -0,0 +1,212 @@
+{
+  "env": {
+    "browser": true,
+    "node": true
+  },
+  "extends": [
+    "plugin:@typescript-eslint/recommended",
+    "plugin:@typescript-eslint/recommended-requiring-type-checking",
+    "prettier",
+    "prettier/@typescript-eslint"
+  ],
+  "parser": "@typescript-eslint/parser",
+  "parserOptions": {
+    "project": "tsconfig.json",
+    "sourceType": "module"
+  },
+  "plugins": [
+    "@typescript-eslint"
+  ],
+  "ignorePatterns": ["*spec.ts", "*.min.js", "protractor.conf.js", "xml2abc.js", "zip.js", "app.po.ts", "karma.conf.js", "test.ts"],
+  "rules": {
+    "@typescript-eslint/adjacent-overload-signatures": "error",
+    "@typescript-eslint/array-type": [
+      "error",
+      {
+        "default": "array"
+      }
+    ],
+    "@typescript-eslint/ban-types": [
+      "error",
+      {
+        "types": {
+          "Object": {
+            "message": "Avoid using the `Object` type. Did you mean `object`?"
+          },
+          "Function": {
+            "message": "Avoid using the `Function` type. Prefer a specific function type, like `() => void`."
+          },
+          "Boolean": {
+            "message": "Avoid using the `Boolean` type. Did you mean `boolean`?"
+          },
+          "Number": {
+            "message": "Avoid using the `Number` type. Did you mean `number`?"
+          },
+          "String": {
+            "message": "Avoid using the `String` type. Did you mean `string`?"
+          },
+          "Symbol": {
+            "message": "Avoid using the `Symbol` type. Did you mean `symbol`?"
+          }
+        }
+      }
+    ],
+    "@typescript-eslint/consistent-type-assertions": "off",
+    "@typescript-eslint/dot-notation": "error",
+    "@typescript-eslint/explicit-member-accessibility": [
+      "off",
+      {
+        "accessibility": "explicit"
+      }
+    ],
+    "@typescript-eslint/member-delimiter-style": [
+      "error",
+      {
+        "multiline": {
+          "delimiter": "semi",
+          "requireLast": true
+        },
+        "singleline": {
+          "delimiter": "semi",
+          "requireLast": true
+        }
+      }
+    ],
+    "@typescript-eslint/no-empty-interface": "error",
+    "@typescript-eslint/no-explicit-any": "off",
+    "@typescript-eslint/no-floating-promises": "error",
+    "@typescript-eslint/no-misused-new": "error",
+    "@typescript-eslint/no-namespace": "error",
+    "@typescript-eslint/no-parameter-properties": "off",
+    "@typescript-eslint/no-unused-expressions": "error",
+    "@typescript-eslint/no-use-before-define": "off",
+    "@typescript-eslint/no-var-requires": "error",
+    "@typescript-eslint/prefer-for-of": "error",
+    "@typescript-eslint/prefer-function-type": "error",
+    "@typescript-eslint/prefer-namespace-keyword": "error",
+    "@typescript-eslint/prefer-regexp-exec": "off",
+    "@typescript-eslint/unbound-method": "off",
+    "@typescript-eslint/restrict-plus-operands": "off",
+    "@typescript-eslint/member-ordering": [
+      "warn",
+      {
+        "default": [
+          "public-static-field",
+          "protected-static-field",
+          "private-static-field",
+          "public-instance-field",
+          "protected-instance-field",
+          "private-instance-field",
+          "constructor",
+          "public-static-method",
+          "protected-static-method",
+          "private-static-method",
+          "public-instance-method",
+          "protected-instance-method",
+          "private-instance-method"
+        ]
+      }
+    ],
+    "@typescript-eslint/no-unused-vars": [
+      "error",
+      {
+        "args": "after-used",
+        "argsIgnorePattern": "^_"
+      }
+    ],
+    "@typescript-eslint/explicit-module-boundary-types": [
+      "warn",
+      {
+        "allowArgumentsExplicitlyTypedAsAny": true
+      }
+    ],
+    "@typescript-eslint/no-inferrable-types": [
+      "warn",
+      {
+        "ignoreParameters": true,
+        "ignoreProperties": true
+      }
+    ],
+    "@typescript-eslint/quotes": [
+      "error",
+      "double"
+    ],
+    "@typescript-eslint/semi": [
+      "error"
+    ],
+    "@typescript-eslint/triple-slash-reference": [
+      "error",
+      {
+        "path": "always",
+        "types": "prefer-import",
+        "lib": "always"
+      }
+    ],
+    "@typescript-eslint/unified-signatures": "error",
+    "camelcase": "off",
+    "comma-dangle": "off",
+    "complexity": "off",
+    "constructor-super": "error",
+    "eqeqeq": [
+      "off",
+      "smart"
+    ],
+    "guard-for-in": "error",
+    "id-blacklist": "off",
+    "id-match": "off",
+    "import/order": "off",
+    "max-classes-per-file": [
+      "error",
+      1
+    ],
+    "max-len": [
+      "off",
+      {
+        "code": 210
+      }
+    ],
+    "new-parens": "error",
+    "no-bitwise": "error",
+    "no-caller": "error",
+    "no-cond-assign": "error",
+    "no-console": "off",
+    "no-debugger": "error",
+    "no-empty": "error",
+    "no-eval": "error",
+    "no-fallthrough": "off",
+    "no-invalid-this": "off",
+    "no-new-wrappers": "error",
+    "no-shadow": [
+      "error",
+      {
+        "hoist": "all"
+      }
+    ],
+    "no-throw-literal": "off",
+    "no-trailing-spaces": "error",
+    "no-undef-init": "error",
+    "no-underscore-dangle": "off",
+    "no-unsafe-finally": "error",
+    "no-unused-labels": "error",
+    "no-var": "error",
+    "object-shorthand": "off",
+    "one-var": [
+      "error",
+      "never"
+    ],
+    "prefer-const": "error",
+    "quote-props": "off",
+    "radix": "error",
+    "spaced-comment": [
+      "error",
+      "always",
+      {
+        "markers": [
+          "/"
+        ]
+      }
+    ],
+    "use-isnan": "error",
+    "valid-typeof": "off"
+  }
+}

package/README.md

@@ -0,0 +1,2 @@
+# smart-db
+Smart DB

package/bin/copy-assets

@@ -0,0 +1,6 @@
+#! /bin/bash
+#
+mkdir -p dist/bin
+cp bin/extract-db-api dist/bin
+rsync -a --delete --delete-excluded assets/ dist/assets/
+cp -p package*.json dist

package/bin/extract-db-api

@@ -0,0 +1,19 @@
+#! /bin/bash
+if [[ -L "$0" ]]; then
+    bin=$(dirname "$0")
+    link=$(readlink "$0")
+    ROOT=$(cd "$bin" >/dev/null && cd "$(dirname "$link")"/.. >/dev/null && pwd)
+else
+    ROOT=$(cd "$(dirname "$0")"/.. >/dev/null && pwd)
+fi
+
+if [[ -d $ROOT/dist ]]; then
+	ROOT=$ROOT/dist
+fi
+
+if [[ -f $ROOT/helpers/extract-db-api.js ]]; then
+    # distribution environment
+    node --es-module-specifier-resolution=node "$ROOT/helpers/extract-db-api.js" "$@"
+else
+    echo "missing smart-db-extract-api script"
+fi

package/package.json

@@ -1,55 +1,84 @@
 {
   "name": "@egi/smart-db",
-  "version": "2.0.3",
+  "version": "2.1.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",
     "clean": "rm -rf dist/*",
     "build": "npm-run-all clean tsc copy-assets",
-    "build-pro": "npm-run-all clean tsc-pro uglify copy-assets",
+    "build-pro": "npm-run-all clean tsc-pro terser copy-assets",
     "build-watch": "npm-run-all clean copy-assets tsc-watch",
     "build-test-models": "tsc --build tsconfig.test-model.json",
     "tsc": "tsc --build tsconfig.json",
     "tsc-pro": "tsc --build tsconfig.pro.json",
     "tsc-watch": "tsc --build tsconfig.json --watch",
-    "uglify": "node dist/helpers/uglify-tree 'dist/**/*.js' && rm -f dist/helpers/uglify-tree.*",
-    "extract-db-interface": "bin/extract-db-interface && tsc --build tsconfig.test-model.json"
+    "terser": "node dist/helpers/terser-tree 'dist/**/*.js' && rm -f dist/helpers/terser-tree.*",
+    "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/src/drivers/smart-db-better-sqlite3.ts

@@ -0,0 +1,284 @@
+import BetterSqlite3 from "better-sqlite3";
+
+import _ from "lodash";
+import { SmartDbSqlBuildData } from "../smart-db-sql-build-data";
+import { AbstractModel } from "../models/abstract-model";
+import { SqliteMasterModel } from "../models/sqlite-master-model";
+import {SmartDb} from "../smart-db";
+import {AbstractModelGlobals, GenericModelData, SmartDbConnector, SmartDbFieldDescription, SmartDbRunResult, SmartDbTableInfo} from "../smart-db-interfaces";
+
+type VariableArgFunction = (...params: any[]) => any;
+
+interface SmartDbSqlite3TableInfo {
+    cid: number;
+    name: string;
+    type: string;
+    notnull: 0;
+    // noinspection SpellCheckingInspection
+    dflt_value: string | number | boolean;
+    pk: number;
+}
+
+// noinspection JSClassNamingConvention
+export class SmartDbBetterSqlite3 extends SmartDb {
+    protected db: BetterSqlite3.Database;
+
+    constructor(connectorOrDb: string | BetterSqlite3.Database, options?: BetterSqlite3.Options) {
+        if (_.isString(connectorOrDb)) {
+            super(connectorOrDb);
+            this.db = new BetterSqlite3(connectorOrDb, options);
+        } else {
+            super(null);
+            this.db = connectorOrDb;
+            this.db.inTransaction;
+        }
+    }
+
+    public getDatabaseType(): string {
+        return "sqlite3";
+    }
+
+    public getDbQuote(): string {
+        return "\"";
+    }
+
+    public getDbConnector(): string | SmartDbConnector {
+        return this.dbConnector;
+    }
+
+    public hasConcurrentTransactions(): boolean {
+        return false;
+    }
+
+    // noinspection JSUnusedGlobalSymbols
+    public exists<T extends AbstractModel<T, D>, D extends GenericModelData>(modelClass: string | (new () => T), type?: "view" | "table" | "index", indexTableName?: string): Promise<boolean> {
+        return new Promise<boolean>((resolve, reject) => {
+            const tableName = _.isString(modelClass) ? modelClass : (<AbstractModelGlobals<T, D>><unknown>modelClass).getTableName();
+
+            this.getFirst(SqliteMasterModel, {
+                name: tableName,
+                type: type,
+                tblName: indexTableName
+            }).then((rows) => {
+                if (rows === null) {
+                    reject(this.getLastError());
+                } else {
+                    resolve(!!rows);
+                }
+            }).catch((err) => {
+                reject(err);
+            });
+        });
+    }
+
+    public existsSync<T extends AbstractModel<T, D>, D extends GenericModelData>(modelClass: string | (new () => T), type?: "view" | "table" | "index", indexTableName?: string): boolean {
+        let exists = false;
+
+        const tableName = _.isString(modelClass) ? modelClass : (<AbstractModelGlobals<T, D>><unknown>modelClass).getTableName();
+
+        const rows = this.getFirstSync(SqliteMasterModel, {
+            name: tableName,
+            type: type,
+            tblName: indexTableName
+        });
+
+        if (rows === false) {
+            throw this.getLastError();
+        } else {
+            exists = !!rows;
+        }
+
+        return exists;
+    }
+
+    public exec(script: string): Promise<any> {
+        return new Promise<any>((resolve, reject) => {
+            const ret = this.execSync(script);
+            if (ret === false) {
+                reject("unable to execute script");
+            } else {
+                resolve(ret);
+            }
+        });
+    }
+
+    public execSync(script: string): BetterSqlite3.Database | false {
+        return this.saveExecute(() => {
+            return this.db.exec(script);
+        });
+    }
+
+    // noinspection JSUnusedGlobalSymbols
+    public transaction<F extends VariableArgFunction>(fn: F): BetterSqlite3.Transaction | false {
+        return this.saveExecute(() => {
+            return this.db.transaction(fn);
+        });
+    }
+
+    // noinspection JSUnusedGlobalSymbols
+    public pragma(source: string, options?: BetterSqlite3.PragmaOptions): unknown {
+        return this.saveExecute(() => {
+            return this.db.pragma(source, options) as unknown;
+        });
+    }
+
+    // noinspection JSUnusedGlobalSymbols
+    public checkpoint(databaseName?: string): BetterSqlite3.Database | false {
+        return this.saveExecute(() => {
+            return this.db.checkpoint(databaseName);
+        });
+    }
+
+    // noinspection JSUnusedGlobalSymbols
+    public func(name: string, options: BetterSqlite3.RegistrationOptions, cb: VariableArgFunction): BetterSqlite3.Database | false {
+        return this.saveExecute(() => {
+            let ret;
+            if (_.isFunction(options)) {
+                ret = this.db.function(name, options);
+            } else {
+                ret = this.db.function(name, options, cb);
+            }
+            return ret;
+        });
+    }
+
+    // noinspection JSUnusedGlobalSymbols
+    public aggregate(name: string, options: BetterSqlite3.AggregateOptions): BetterSqlite3.Database | false {
+        return this.saveExecute(() => {
+            return this.db.aggregate(name, options);
+        });
+    }
+
+    // noinspection JSUnusedGlobalSymbols
+    public loadExtension(path: string): BetterSqlite3.Database | false {
+        return this.saveExecute(() => {
+            return this.db.loadExtension(path);
+        });
+    }
+
+    // noinspection JSUnusedGlobalSymbols
+    public closeSync(): boolean {
+        return this.saveExecute(() => {
+            this.smartDbLog.setDb(null);
+            return !!this.db.close();
+        });
+    }
+
+    // noinspection JSUnusedGlobalSymbols
+    public defaultSafeIntegers(toggleState?: boolean): BetterSqlite3.Database | false {
+        return this.saveExecute(() => {
+            return this.db.defaultSafeIntegers(toggleState);
+        });
+    }
+
+    // noinspection JSUnusedGlobalSymbols
+    public backup(destinationFile: string, options?: BetterSqlite3.BackupOptions): Promise<BetterSqlite3.BackupMetadata> | false {
+        return this.saveExecute(() => {
+            return this.db.backup(destinationFile, options);
+        });
+    }
+
+    public getTableInfo(tableName: string): Promise<SmartDbTableInfo> {
+        return new Promise<SmartDbTableInfo>((resolve) => {
+
+            const infos = this.pragma(`table_info(${tableName})`) as SmartDbSqlite3TableInfo[];
+            let fieldInfos: SmartDbFieldDescription[] = [];
+            if (infos) {
+                fieldInfos = infos.map((info) => {
+                    return <SmartDbFieldDescription>{
+                        cid: info.cid,
+                        name: info.name,
+                        type: info.type,
+                        notNull: info.notnull !== 0,
+                        defaultValue: info.dflt_value,
+                        isPk: info.pk !== 0
+                    };
+                });
+
+                resolve({
+                    name: tableName,
+                    fields: fieldInfos
+                });
+            }
+        });
+    }
+
+    protected statementRun(buildData: SmartDbSqlBuildData, retry: number = 0): Promise<SmartDbRunResult> {
+        return new Promise<SmartDbRunResult>((resolve, reject) => {
+            try {
+                resolve(this.statementRunSync(buildData));
+            } catch (err) {
+                if (err.code == "SQLITE_BUSY") {
+                    if (retry < 10) {
+                        setTimeout(() => {
+                            this.statementRun(buildData, retry + 1).then((result) => {
+                                resolve(result);
+                            }).catch((err) => {
+                                reject(err);
+                            });
+                        }, 100);
+                    } else {
+                        reject(err);
+                    }
+                } else {
+                    reject(err);
+                }
+            }
+        });
+    }
+
+    protected statementRunSync(buildData: SmartDbSqlBuildData): SmartDbRunResult {
+        const stmt = this.db.prepare(buildData.sql);
+        const runResult = stmt && stmt.run(buildData.values);
+        return runResult && {
+            changes: runResult.changes,
+            affected: runResult.changes,
+            lastId: runResult.lastInsertRowid as number
+        };
+    }
+
+    protected statementGet(buildData: SmartDbSqlBuildData): Promise<any> {
+        return new Promise<any>((resolve, reject) => {
+            try {
+                const stmt = this.db.prepare(buildData.sql);
+                resolve(stmt.get(buildData.values));
+            } catch (err) {
+                reject(err);
+            }
+        });
+    }
+
+    protected statementGetSync(buildData: SmartDbSqlBuildData) {
+        const stmt = this.db.prepare(buildData.sql);
+        return stmt && stmt.get(buildData.values);
+    }
+
+    protected statementGetAll(buildData: SmartDbSqlBuildData): Promise<any[]> {
+        return new Promise<any[]>((resolve, reject) => {
+            try {
+                const stmt = this.db.prepare(buildData.sql);
+                resolve(stmt.all(buildData.values));
+            } catch (err) {
+                reject(err);
+            }
+        });
+    }
+
+    protected statementGetAllSync(buildData: SmartDbSqlBuildData): any[] {
+        const stmt = this.db.prepare(buildData.sql);
+        return stmt && stmt.all(buildData.values);
+    }
+
+    // noinspection JSUnusedGlobalSymbols
+    public close(): Promise<void> {
+        return new Promise<void>((resolve, reject) => {
+            try {
+                this.smartDbLog.setDb(null);
+                this.db.close();
+                resolve();
+            } catch (err) {
+                reject(err);
+            }
+        });
+    }
+}