@egi/smart-db 2.3.2 → 2.3.4

package/.eslintrc.json

@@ -1,212 +0,0 @@
-{
-  "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

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

package/bin/copy-assets

@@ -1,6 +0,0 @@
-#! /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/src/drivers/smart-db-better-sqlite3.ts

@@ -1,284 +0,0 @@
-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);
-            }
-        });
-    }
-}

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

@@ -1,159 +0,0 @@
-// noinspection JSUnusedGlobalSymbols
-
-import _ from "lodash";
-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 {AbstractModelGlobals, GenericModelData, SmartDbRunResult, SmartDbTableInfo} from "../smart-db-interfaces";
-
-// noinspection DuplicatedCode
-export class SmartDbMysql extends SmartDb {
-    protected db: Mysql.Connection;
-
-    constructor(connectorOrDb: string | ConnectionConfig | Connection) {
-        if ((<Connection>connectorOrDb).config && (<Connection>connectorOrDb).connect) {
-            super((<Connection>connectorOrDb).config);
-            this.db = connectorOrDb as Mysql.Connection;
-        } else {
-            super(connectorOrDb);
-            this.db = Mysql.createConnection(connectorOrDb as ConnectionConfig | string);
-        }
-    }
-
-    public getDatabaseType(): string {
-        return "mysql";
-    }
-
-    public getDbConnector(): string | Mysql.ConnectionConfig {
-        return this.dbConnector;
-    }
-
-    public getDbQuote(): string {
-        return "`";
-    }
-
-    public hasConcurrentTransactions(): boolean {
-        return true;
-    }
-
-    public closeSync(): boolean {
-        throw new Error("Method not implemented.");
-    }
-
-    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.db.query(`show tables like '${tableName}'`, (error, result: any[], fields) => {
-                if (error) {
-                    reject(error);
-                } else {
-                    resolve(result && result.length > 0);
-                }
-            });
-        });
-    }
-
-    public existsSync<T extends AbstractModel<T, D>, D extends GenericModelData>(modelClass: string | (new () => T), type?: "view" | "table" | "index", indexTableName?: string): boolean {
-        throw new Error("Method not implemented.");
-    }
-
-    public exec(script: string): Promise<void> {
-        return new Promise<void>((resolve, reject) => {
-            try {
-                this.db.query(script, (error, result, fields) => {
-                    if (error) {
-                        reject(error);
-                    } else {
-                        resolve();
-                    }
-                });
-            } catch (err) {
-                reject(err);
-            }
-        });
-    }
-
-    public execSync(script: string): boolean {
-        throw new Error("Method not implemented.");
-    }
-
-    public getTableInfo(table: string): Promise<SmartDbTableInfo> {
-        return new Promise<SmartDbTableInfo>((resolve, reject) => {
-
-        });
-    }
-
-    protected statementGet(buildData: SmartDbSqlBuildData): Promise<any> {
-        return new Promise<any>((resolve, reject) => {
-            try {
-                this.db.query(buildData.sql, buildData.values, (error, rows, fields) => {
-                    if (error) {
-                        reject(error);
-                    } else {
-                        resolve(rows && rows[0]);
-                    }
-                });
-            } catch (err) {
-                reject(err);
-            }
-        });
-    }
-
-    protected statementGetSync(buildData: SmartDbSqlBuildData): any {
-        throw new Error("Method not implemented.");
-    }
-
-    protected statementGetAll(buildData: SmartDbSqlBuildData): Promise<any[]> {
-        return new Promise<any[]>((resolve, reject) => {
-            this.db.query(buildData.sql, buildData.values, (error, rows, fields) => {
-                if (error) {
-                    reject(error);
-                } else {
-                    console.log(fields);
-                    resolve(rows && rows);
-                }
-            });
-        });
-    }
-
-    protected statementGetAllSync(buildData: SmartDbSqlBuildData): any[] {
-        throw new Error("Method not implemented.");
-    }
-
-    protected statementRun(buildData: SmartDbSqlBuildData): Promise<SmartDbRunResult> {
-        return new Promise<SmartDbRunResult>((resolve, reject) => {
-            this.db.query(buildData.sql, buildData.values, (error, results, fields) => {
-                if (error) {
-                    reject(error);
-                } else {
-                    const runResult: SmartDbRunResult = {
-                        changes: results.changedRows,
-                        affected: results.affectedRows,
-                        lastId: results.insertId
-                    };
-                    resolve(runResult);
-                }
-            });
-        });
-    }
-
-    protected statementRunSync(buildData: SmartDbSqlBuildData): SmartDbRunResult {
-        throw new Error("Method not implemented.");
-    }
-
-    public close(): Promise<void> {
-        return new Promise<void>((resolve, reject) => {
-            this.db.end((err) => {
-                if (err) {
-                    reject(err);
-                } else {
-                    resolve();
-                }
-            });
-        });
-    }
-}