multi-db-orm 2.1.27 → 3.0.1

package/README.md

@@ -1,34 +1,39 @@
 # multi-db-orm
-ORM for multiple SQL and NoSQL databases like firestore , MongoDB , SQlite with Sync ,  Backup and Restore support .
+
+ORM for multiple SQL and NoSQL databases like firestore , MongoDB , SQlite with Sync , Backup and Restore support .
 
 [![NPM Publish](https://github.com/shiveshnavin/multi-db-orm/actions/workflows/npm-publish.yml/badge.svg)](https://github.com/shiveshnavin/multi-db-orm/actions/workflows/npm-publish.yml)
 
 ## 1. Object Relational Mapping
 
 Supported databases:
+
 1. MongoDB
 2. Google Firestore
 3. SQlite3
 4. Oracle
-4. MySQL
+5. MySQL
 
 ### Install
+
 The package is available on npm
-`
-npm install multi-db-orm
-`
+`npm install multi-db-orm`
 
 ### Initialize
+
 Install the target optional database dependencies based on your usage
+
 ```
 npm install --save mongodb
 npm install --save firebase-admin
 npm install --save sqlite3
 npm install --save oracledb oracle-instantclient
 npm install --save mysql
+npm install --save @sap/hana-client
 ```
 
 Configure the database
+
 ```
 const { MultiDbORM, FireStoreDB, MongoDB, SQLiteDB, MySQLDB, Sync } = require("multi-db-orm");
 
@@ -64,29 +69,42 @@ var mysqldb = new MySQLDB({
     "database": "test"
 });
 
+// HanaDB
+var mysqldb = new HanaDB({
+    "host": "db.hana.com",
+    "port": "443",
+    "username": "test",
+    "password": "Password@123"
+});
 var db = firebasedb;
 ```
 
-### Usage 
+### Usage
+
 You can perform Create,Insert,Get,GetOne,Update,Delete queries . You only need to base your code on the interface MultiDbORM
 
 <b>Note:</b>
- 1. Firestore DB requires a `documentPath` specified for each document in a collection . For FirestoreDB functions you can optionally specify this path as the last parameter in getOne,update,insert,delete functions or have a 'id' field in all your objects . If none are specified the Date.now() is used.
- 2. All the functions are `async` i.e. they return a promise so you can use `..then()` or `await`
+
+1.  Firestore DB requires a `documentPath` specified for each document in a collection . For FirestoreDB functions you can optionally specify this path as the last parameter in getOne,update,insert,delete functions or have a 'id' field in all your objects . If none are specified the Date.now() is used.
+2.  All the functions are `async` i.e. they return a promise so you can use `..then()` or `await`
 
 #### Create
+
 You can create a Table from a sample object in SQlite . NoSQL databases need not create a entity explicitly .
+
 ```
 // db.create(modelname,sampleObject)
 
 var db = new SQLiteDB("/path/to/mydatabase.db"); // if no path is passed , an in-memory db is used
-db.create('game',aSampleGameObject); 
-// creates a game table in db . 
+db.create('game',aSampleGameObject);
+// creates a game table in db .
 // The fields and their data types are extracted from aSampleGameObject but aSampleGameObject is not saved in db
 ```
 
 #### Insert
+
 The same code will insert a object to the database entity based on the Implementation of MultiDbORM selected from Initialize Step above . Calling `db.insert()` returns a promise so can be used with async/await easily .
+
 ```
 // db.insert(modelname,object)
 
@@ -102,22 +120,25 @@ db.insert('game', gm).then(response=>{
 ```
 
 #### Get
+
 The code will retrieve object(s) from the database .
+
 ```
 // db.get(modelname,filter)
 
-var games = await db.get('game', { amount: 19.00 , type: 'Hockey' }); 
+var games = await db.get('game', { amount: 19.00 , type: 'Hockey' });
 // returns an array of games having amount = 19.00 and type = Hockey
 
-var oneGame = await db.getOne('game', { country: 'India' }); // returns single game having country = 19.00 
+var oneGame = await db.getOne('game', { country: 'India' }); // returns single game having country = 19.00
 
-var oneGameFr = await db.getOne('game', { country: 'India' },"32g274hfn48vnf")); 
+var oneGameFr = await db.getOne('game', { country: 'India' },"32g274hfn48vnf"));
 // Only for firestore if docPath is passed optionally , filter is ignored and the object is returned
 ```
 
-
 #### Get with Range and sort
+
 The code will retrieve object(s) from the database with range (supported range operations : > , < , >= , >= , != , = ) and sort (asc or desc) on single field , limit and offset.
+
 ```
 var gamesFr = await mongodb.get('games', { amount: 400 }, {
             apply: {
@@ -134,75 +155,83 @@ var gamesFr = await mongodb.get('games', { amount: 400 }, {
 ```
 
 #### Get with Sort , Limit and Offset
+
 The code will retrieve object(s) from the database with sort (asc or desc) , limit and offset.
+
 ```
-var oneGameFr = await mongodb.get('game', 
+var oneGameFr = await mongodb.get('game',
  { country: 'India' },
  { sort: [{ field: 'timeStamp', order: 'asc' },
- { field: 'amount', order: 'asc' }], 
-  limit: 5, offset: 1 
+ { field: 'amount', order: 'asc' }],
+  limit: 5, offset: 1
 })
 
 ```
-Note : 
+
+Note :
+
 1. For firestore indexes have to be created before using sort . In case indexes are not there you will get an error in the console with a link where you can create the required index .
 2. sort is not applicable when using apply and will be ignored
 
-
 #### Update
+
 The code will update objects in the database .
+
 ```
 // db.update(modelname,filter,object)
 
 
-var result = await db.update('game', { amount: 19.00 , type: 'Hockey' },{status : "cancelled",closingTime:Date.now()}); 
-// updates all the games having amount=19.00 and type=Hockey to status=cancelled 
+var result = await db.update('game', { amount: 19.00 , type: 'Hockey' },{status : "cancelled",closingTime:Date.now()});
+// updates all the games having amount=19.00 and type=Hockey to status=cancelled
 // and closingTime as current time while other fields are not touched
 
-var result_fire = await db.update('game', { amount: 19.00 , type: 'Hockey' },"32g274hfn48vnf"); 
+var result_fire = await db.update('game', { amount: 19.00 , type: 'Hockey' },"32g274hfn48vnf");
 /* Only for firestore with optional docPath , it will update collection("game").doc("32g274hfn48vnf") .
 The filters amount and type are ignored when docPath is passed */
 ```
 
 #### Delete
+
 The code will delete objects in the database .
-````
+
+```
 // db.delete(modelname,filter)
 
 
-var result = await db.delete('game', { amount: 19.00 , type: 'Hockey' }); 
-// deletes all the games having amount=19.00 and type=Hockey  
+var result = await db.delete('game', { amount: 19.00 , type: 'Hockey' });
+// deletes all the games having amount=19.00 and type=Hockey
 
 var result_fire = await db.delete('game', { amount: 19.00 , type: 'Hockey' },"32g274hfn48vnf");
 /* Only for firestore with optional docPath , it will delete collection("game").doc("32g274hfn48vnf") .
 The filters amount and type are ignored when docPath is passed */
-````
-
-
-
+```
 
 ## 2. Migration
 
 #### Mongo DB
 
-Pass your SOURCE and TARGET DB credentials 
+Pass your SOURCE and TARGET DB credentials
 
 Using Docker
+
 ```
 docker run shiveshnavin/multi-db-safe 'mongodb://username:paswd@dbhost:13873/sourceDBName' 'mongodb://username:paswd@dbhost:13873/targetDBName' 0
- 
+
 ```
+
 Using Shell
+
 ```
 ./migrate.sh 'mongodb://username:paswd@dbhost:13873/sourceDBName' 'mongodb://username:paswd@dbhost:13873/targetDBName' 0
- 
+
 ```
- 
+
 Note : To run deduplication as well set 1 instead of 0 at last cmd line argument
 
-## 3. Backup 
+## 3. Backup
 
 #### Mongo DB
+
 ```
 node backup.js 'mongodb://username:paswd@dbhost:13873/sourceDBName'
 ```
@@ -212,18 +241,19 @@ This will create a dump file in dumps/
 ## 4. Restore
 
 #### Mongo DB
+
 ```
-Without Deduplication : node restore.js dumpfile.json 'mongodb://username:paswd@dbhost:13873/targetDBName' 
+Without Deduplication : node restore.js dumpfile.json 'mongodb://username:paswd@dbhost:13873/targetDBName'
 
 With Deduplication : node restore.js dumpfile.json 'mongodb://username:paswd@dbhost:13873/targetDBName' 1
 ```
 
-
 ## 5. Work in Progress
+
 Working on enhancing the tool with below features in progress. Feel free to contribute and create a PR .
 
 - [ ] Add Backup support for other databases
 - [ ] Add Restore support for other databases
-- [X] Range Operations like `>=` `<=` 
+- [x] Range Operations like `>=` `<=`
 - [ ] Aggregations
 - [ ] InsertMany

package/databases.js

@@ -2,14 +2,16 @@ const { MultiDbORM } = require("./engines/multidb");
 const { FireStoreDB } = require("./engines/firestoredb");
 const { MongoDB } = require("./engines/mongodb");
 const { SQLiteDB } = require("./engines/sqlitedb");
-const { OracleDB } = require('./engines/oracledb')
-const { MySQLDB } = require('./engines/mysqldb')
+const { OracleDB } = require("./engines/oracledb");
+const { MySQLDB } = require("./engines/mysqldb");
+const { HanaDB } = require("./engines/hanadb");
 
 module.exports = {
-    MultiDbORM,
-    FireStoreDB,
-    MongoDB,
-    SQLiteDB,
-    OracleDB,
-    MySQLDB
-}
+  MultiDbORM,
+  FireStoreDB,
+  MongoDB,
+  SQLiteDB,
+  OracleDB,
+  MySQLDB,
+  HanaDB,
+};

package/engines/hanadb.d.ts

@@ -0,0 +1,24 @@
+import { MultiDbORM } from './multidb';
+
+export type HanaDBConfig = {
+    host: string;
+    port: string;
+    username: string;
+    password: string;
+    database?: string;
+    connectionLimit?: Number;
+    connectTimeout?: Number;
+    acquireTimeout?: Number;
+    timeout?: Number;
+}
+
+export class HanaDB extends MultiDbORM {
+    declare db: typeof import('@sap/hana-client')
+    connection: any;
+
+    constructor(credentials: HanaDBConfig);
+
+    run(query: string): Promise<any[]>;
+
+    closePool(): void;
+}

package/engines/hanadb.js

@@ -0,0 +1,249 @@
+const { MultiDbORM } = require("./multidb");
+
+class HanaDB extends MultiDbORM {
+  db;
+  conn;
+  dataMap = {
+    id: "VARCHAR(50) NOT NULL PRIMARY KEY",
+    string: "NVARCHAR(4000)",
+    stringlarge: "NCLOB",
+    stringsmall: "NVARCHAR(255)",
+    number: "DOUBLE",
+    boolean: "BOOLEAN",
+    array: "NCLOB",
+    object: "NCLOB",
+  };
+
+  constructor(credentials) {
+    super();
+    const hana = require("@sap/hana-client");
+    this.db = hana;
+    this.conn_params = {
+      ...credentials,
+      host: credentials.host,
+      port: credentials.port,
+      serverNode: `${credentials.host}:${credentials.port}`,
+      uid: credentials.username,
+      pwd: credentials.password,
+      databaseName: credentials.database,
+      communicationTimeout: credentials.connectionLimit || 60000,
+      connectTimeout: credentials.connectionLimit || 60000,
+      reconnect: credentials.reconnect ?? true,
+      poolOptions: {
+        maxPoolSize: credentials.connectionLimit || 10,
+        idleTimeout: credentials.timeout || 60000,
+      },
+    };
+    this.conn = hana.createConnection();
+    this.db = this.conn;
+    this.dbType = "hana";
+    this.reqMade = 0;
+  }
+
+  async run(query) {
+    const that = this;
+    this.reqMade++;
+    return new Promise((resolve, reject) => {
+      let onConnect = function (err) {
+        if (err) throw err;
+        that.conn.exec(query, (err, result) => {
+          if (err) {
+            reject(err);
+          } else {
+            resolve(result);
+          }
+          if (that.loglevel > 3) {
+            console.log("Query", query, "->", result);
+          }
+        });
+      };
+      if (that.conn.state() == "disconnected") {
+        that.conn.connect(that.conn_params, onConnect);
+      } else {
+        onConnect();
+      }
+    });
+  }
+
+  async get(modelname, filter, options) {
+    this.metrics.get(modelname, filter, options);
+    let where = "";
+    for (const key in filter) {
+      where += `${key} = '${filter[key]}' AND `;
+    }
+    where += "1 = 1";
+    let sort = "";
+    if (options) {
+      if (options.apply) {
+        if (options.apply.ineq) {
+          where += ` AND ${options.apply.field} ${options.apply.ineq.op} '${options.apply.ineq.value}'`;
+        }
+        if (options.apply.sort) {
+          sort = `ORDER BY ${options.apply.field} ${options.apply.sort}`;
+        }
+      } else if (options.sort) {
+        sort = "ORDER BY";
+        for (let i = 0; i < options.sort.length; i++) {
+          sort += ` ${options.sort[i].field} ${options.sort[i].order}`;
+          if (i < options.sort.length - 1) {
+            sort += ", ";
+          }
+        }
+      }
+    }
+    const limit = options?.limit ? `LIMIT ${options.limit}` : "";
+    const offset = options?.offset ? `OFFSET ${options.offset}` : "";
+    const query = `SELECT * FROM ${modelname} WHERE ${where} ${sort} ${limit} ${offset};`;
+    return (await this.run(query)) || [];
+  }
+  escapeSQLValue(value) {
+    if (typeof value === "string") {
+      return `'${value.replace(/'/g, "''")}'`;
+    } else if (value === null || value === undefined) {
+      return "NULL";
+    }
+    return value;
+  }
+  async getOne(modelname, filter) {
+    this.metrics.getOne(modelname, filter);
+    let where = "";
+    for (const key in filter) {
+      where += `${key} = '${filter[key]}' AND `;
+    }
+    where += "1 = 1";
+    const query = `SELECT * FROM ${modelname} WHERE ${where} LIMIT 1;`;
+    const row = await this.run(query);
+    return row[0];
+  }
+
+  async create(modelname, sampleObject) {
+    this.sync.create(modelname, sampleObject);
+    this.metrics.create(modelname, sampleObject);
+
+    let cols = "";
+    for (const key in sampleObject) {
+      let type;
+      if (this.dataMap[sampleObject[key]]) {
+        type = this.dataMap[sampleObject[key]];
+      } else {
+        type = this.dataMap[typeof sampleObject[key]] || "NCLOB";
+        if (typeof sampleObject[key] === "string") {
+          if (sampleObject[key].length > 4000) {
+            type = this.dataMap["stringlarge"];
+          }
+          if (sampleObject[key].length <= 255) {
+            type = this.dataMap["stringsmall"];
+          }
+        }
+      }
+
+      if (key.toLowerCase().trim() === "id") {
+        cols += `${key} ${type} PRIMARY KEY NOT NULL ,`;
+      } else {
+        cols += `${key} ${type},`;
+      }
+    }
+    cols = cols.substring(0, cols.length - 1);
+    const query = `CREATE COLUMN TABLE ${modelname} (${cols});`;
+    try {
+      return await this.run(query);
+    } catch (err) {
+      if (this.loglevel > 0) console.log(err);
+      throw err;
+    }
+  }
+
+  async insert(modelname, object) {
+    this.sync.insert(modelname, object);
+    this.metrics.insert(modelname, object);
+    let cols = "";
+    let vals = "";
+    for (const key in object) {
+      cols = cols + `${key},`;
+      let val = object[key];
+      if (typeof val == "object") val = JSON.stringify(object[key]);
+      val = this.escapeSQLValue(val);
+      if (typeof val == "undefined") vals = vals + `Null,`;
+      else if (typeof val == "boolean") vals = vals + `${val},`;
+      else if (typeof val == "number") vals = vals + `${val},`;
+      else vals = vals + `${val},`;
+    }
+    cols = cols.slice(0, -1);
+    vals = vals.slice(0, -1);
+
+    const query = `INSERT INTO ${modelname} (${cols}) VALUES (${vals});`;
+
+    try {
+      return await this.run(query);
+    } catch (err) {
+      if (err.code && err.code === "259") {
+        // Table does not exist
+        await this.create(modelname, object);
+        return await this.run(query);
+      } else {
+        throw err;
+      }
+    }
+  }
+
+  async update(modelname, filter, object) {
+    this.sync.update(modelname, filter, object);
+    this.metrics.update(modelname, filter, object);
+
+    let where = "";
+    let vals = "";
+    for (const key in filter) {
+      where += `${key} = '${filter[key]}' AND `;
+    }
+    for (const key in object) {
+      let val = object[key];
+      if (typeof val === "object" && val != null)
+        val = JSON.stringify(object[key]);
+      val = this.escapeSQLValue(val);
+
+      vals += `${key} = ${val},`;
+    }
+    where += "1 = 1";
+    vals = vals.slice(0, -1);
+
+    const query = `UPDATE ${modelname} SET ${vals} WHERE ${where};`;
+    try {
+      return await this.run(query);
+    } catch (e) {
+      if (this.loglevel > 4) console.log("Error in update", e);
+      throw e;
+    }
+  }
+
+  async delete(modelname, filter) {
+    this.sync.delete(modelname, filter);
+    this.metrics.delete(modelname, filter);
+
+    let where = "";
+    for (const key in filter) {
+      where += `${key} = '${filter[key]}' AND `;
+    }
+    where += "1 = 1";
+    const query = `DELETE FROM ${modelname} WHERE ${where};`;
+    return await this.run(query);
+  }
+
+  closePool() {
+    return new Promise((resolve, reject) => {
+      this.conn.disconnect((err) => {
+        if (err) {
+          reject(err);
+          if (this.loglevel > 1)
+            console.error("Error closing connection pool:", err);
+        } else {
+          resolve();
+          if (this.loglevel > 1) console.log("HanaDB: Connection pool closed");
+        }
+      });
+    });
+  }
+}
+
+module.exports = {
+  HanaDB,
+};

package/engines/index.d.ts

@@ -1,6 +1,7 @@
 export * from './multidb';
 export * from './sqlitedb';
-export *  from './mongodb';
+export * from './mongodb';
 export * from './firestoredb';
 export * from './oracledb';
 export * from './mysqldb';
+export * from './hanadb';

package/index.js

@@ -1,12 +1,21 @@
-const { MultiDBSafe, FireStoreDB, MongoDB, SQLiteDB, OracleDB, MySQLDB } = require("./databases");
+const {
+  MultiDBSafe,
+  FireStoreDB,
+  MongoDB,
+  SQLiteDB,
+  OracleDB,
+  MySQLDB,
+  HanaDB,
+} = require("./databases");
 const { Sync } = require("./sync");
 
 module.exports = {
-    MultiDBSafe,
-    FireStoreDB,
-    MongoDB,
-    SQLiteDB,
-    OracleDB,
-    MySQLDB,
-    Sync
-}
+  MultiDBSafe,
+  FireStoreDB,
+  MongoDB,
+  SQLiteDB,
+  OracleDB,
+  MySQLDB,
+  HanaDB,
+  Sync,
+};

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "multi-db-orm",
-  "version": "2.1.27",
+  "version": "3.0.1",
   "description": "CRUD , Backup , Restore and Migration library for multiple databases",
   "main": "index.js",
   "dependencies": {
     "fs": "0.0.1-security"
   },
   "devDependencies": {
+    "@sap/hana-client": "^2.23.24",
     "firebase-admin": "^9.3.0",
     "mongodb": "^3.6.3",
     "mysql": "^2.18.1",
@@ -46,4 +47,4 @@
     "url": "https://github.com/shiveshnavin/multi-db-orm/issues"
   },
   "homepage": "https://github.com/shiveshnavin/multi-db-orm#readme"
-}
+}

package/test/test.js

@@ -1,280 +1,434 @@
 const { Game } = require("./models");
-const { MultiDBSafe, FireStoreDB, MongoDB, SQLiteDB, Sync, OracleDB } = require("../index");
-const path = require('path');
+const {
+  MultiDBSafe,
+  FireStoreDB,
+  MongoDB,
+  SQLiteDB,
+  Sync,
+  OracleDB,
+} = require("../index");
+const path = require("path");
 const { MySQLDB } = require("../engines/mysqldb");
+const { HanaDB } = require("../engines/hanadb");
 
-
-
-var testCount = 0
+var testCount = 0;
 function checkTestsCompleted() {
-    if (--testCount <= 0) {
-        process.exit(0)
-    }
+  if (--testCount <= 0) {
+    process.exit(0);
+  }
 }
 
 async function testSqlite() {
-    var sqlitedb = new SQLiteDB();
-    console.log(sqlitedb.metrics.getStatus())
-    var gm = new Game('IndVSPak', Date.now(), 'Dhoni', 67.33, 'paid')
-    sqlitedb.loglevel = 1
-    var res = await sqlitedb.create('games', gm);
-    res = await sqlitedb.insert('games', gm);
-    res = await sqlitedb.insert('games', gm);
-    gm.amount = 1
-    res = await sqlitedb.insert('games', gm);
-    res = await sqlitedb.get('games', { amount: 1 });
-    res = await sqlitedb.getOne('games', { amount: 1 });
-    res = await sqlitedb.update('games', { amount: 1 }, { userid: 'xxxx' });
-    res = await sqlitedb.getOne('games', { userid: 'xxxx' });
-
-    res = await sqlitedb.insert('games', new Game('IndVSPak1', Date.now(), 'Dhoni', 100, 'free'));
-
-    res = await sqlitedb.insert('games', new Game('IndVSPak2', Date.now(), 'Dhoni', 200, 'free'));
-
-    res = await sqlitedb.insert('games', new Game('IndVSPak3', Date.now(), 'Dhoni', 300, 'paid'));
-
-    res = await sqlitedb.insert('games', new Game('IndVSPak4', Date.now(), 'Dhoni', 400, 'paid'));
-
-    res = await sqlitedb.get('games', undefined, { sort: [{ field: 'timeStamp', order: 'asc' }, { field: 'amount', order: 'asc' }], limit: 5, offset: 1 })
-
-    res = await sqlitedb.get('games', { type: 'paid' }, { sort: [{ field: 'amount', order: 'desc' }, { field: 'timeStamp', order: 'desc' }] })
-
-    res = await sqlitedb.get('games', { amount: 400 }, {
-        apply: {
-            field: 'timeStamp',
-            sort: 'desc',
-            ineq: {
-                op: '>=',
-                value: 1
-            }
+  var sqlitedb = new SQLiteDB();
+  console.log(sqlitedb.metrics.getStatus());
+  var gm = new Game("IndVSPak", Date.now(), "Dhoni", 67.33, "paid");
+  sqlitedb.loglevel = 1;
+  var res = await sqlitedb.create("games", gm);
+  res = await sqlitedb.insert("games", gm);
+  res = await sqlitedb.insert("games", gm);
+  gm.amount = 1;
+  res = await sqlitedb.insert("games", gm);
+  res = await sqlitedb.get("games", { amount: 1 });
+  res = await sqlitedb.getOne("games", { amount: 1 });
+  res = await sqlitedb.update("games", { amount: 1 }, { userid: "xxxx" });
+  res = await sqlitedb.getOne("games", { userid: "xxxx" });
+
+  res = await sqlitedb.insert(
+    "games",
+    new Game("IndVSPak1", Date.now(), "Dhoni", 100, "free")
+  );
+
+  res = await sqlitedb.insert(
+    "games",
+    new Game("IndVSPak2", Date.now(), "Dhoni", 200, "free")
+  );
+
+  res = await sqlitedb.insert(
+    "games",
+    new Game("IndVSPak3", Date.now(), "Dhoni", 300, "paid")
+  );
+
+  res = await sqlitedb.insert(
+    "games",
+    new Game("IndVSPak4", Date.now(), "Dhoni", 400, "paid")
+  );
+
+  res = await sqlitedb.get("games", undefined, {
+    sort: [
+      { field: "timeStamp", order: "asc" },
+      { field: "amount", order: "asc" },
+    ],
+    limit: 5,
+    offset: 1,
+  });
+
+  res = await sqlitedb.get(
+    "games",
+    { type: "paid" },
+    {
+      sort: [
+        { field: "amount", order: "desc" },
+        { field: "timeStamp", order: "desc" },
+      ],
+    }
+  );
+
+  res = await sqlitedb.get(
+    "games",
+    { amount: 400 },
+    {
+      apply: {
+        field: "timeStamp",
+        sort: "desc",
+        ineq: {
+          op: ">=",
+          value: 1,
         },
-        sort: [{ field: 'amount', order: 'asc' }, { field: 'timeStamp', order: 'desc' }],
-        limit: 2, offset: 1
-    })
+      },
+      sort: [
+        { field: "amount", order: "asc" },
+        { field: "timeStamp", order: "desc" },
+      ],
+      limit: 2,
+      offset: 1,
+    }
+  );
 
-    console.log('SQLite DB Tests Successfull')
-    console.log(sqlitedb.metrics.getStatus())
-    checkTestsCompleted();
+  console.log("SQLite DB Tests Successfull");
+  console.log(sqlitedb.metrics.getStatus());
+  checkTestsCompleted();
 }
 
-
 async function testFireStore() {
-    try {
-        require('../creds.json')
-
-    } catch (e) {
-        console.log('testFireStore', 'creds.json not found');
-        checkTestsCompleted();
-        return
+  try {
+    require("../creds.json");
+  } catch (e) {
+    console.log("testFireStore", "creds.json not found");
+    checkTestsCompleted();
+    return;
+  }
+  var firebasedb = new FireStoreDB(require("../creds.json"));
+  console.log(firebasedb.metrics.getStatus());
+
+  var gm = new Game("IndVSPak", Date.now(), "Dhoni", 67.33, "free");
+  firebasedb.loglevel = 1;
+  var res = await firebasedb.create("games", gm);
+  res = await firebasedb.insert("games", gm, Date.now());
+  res = await firebasedb.insert("games", gm, Date.now());
+  gm.amount = 1;
+  res = await firebasedb.insert("games", gm);
+  res = await firebasedb.get("games", { amount: 67.33 });
+  res = await firebasedb.getOne("games", { amount: 1 });
+  res = await firebasedb.update(
+    "games",
+    { userid: "Dhoni" },
+    { userid: "ABC123" }
+  );
+  res = await firebasedb.update("games", { id: "IndVSPak" }, { amount: 1000 });
+  await firebasedb.delete("games", { type: "free" });
+
+  res = await firebasedb.insert(
+    "games",
+    new Game("IndVSPak1", Date.now(), "Dhoni", 100, "free")
+  );
+
+  res = await firebasedb.insert(
+    "games",
+    new Game("IndVSPak2", Date.now(), "Dhoni", 200, "free")
+  );
+
+  res = await firebasedb.insert(
+    "games",
+    new Game("IndVSPak3", Date.now(), "Dhoni", 300, "paid")
+  );
+
+  res = await firebasedb.insert(
+    "games",
+    new Game("IndVSPak4", Date.now(), "Dhoni", 400, "paid")
+  );
+
+  res = await firebasedb.get("games", undefined, {
+    sort: [{ field: "amount", order: "desc" }],
+  });
+
+  res = await firebasedb.get("games", undefined, {
+    sort: [{ field: "amount", order: "desc" }],
+    limit: 2,
+    offset: 1,
+  });
+
+  // res = await firebasedb.get('games', {type:'paid'}, { sort: [{ field: 'amount', order: 'asc' }, { field: 'timeStamp', order: 'desc' }] })
+
+  res = await firebasedb.get(
+    "games",
+    { amount: 100 },
+    {
+      apply: {
+        field: "timeStamp",
+        sort: "desc",
+        ineq: {
+          op: ">=",
+          value: 1,
+        },
+      },
+      sort: [
+        { field: "amount", order: "asc" },
+        { field: "timeStamp", order: "desc" },
+      ],
+      limit: 2,
+      offset: 1,
     }
-    var firebasedb = new FireStoreDB(require('../creds.json'));
-    console.log(firebasedb.metrics.getStatus())
-
-    var gm = new Game('IndVSPak', Date.now(), 'Dhoni', 67.33, 'free')
-    firebasedb.loglevel = 1
-    var res = await firebasedb.create('games', gm);
-    res = await firebasedb.insert('games', gm, Date.now());
-    res = await firebasedb.insert('games', gm, Date.now());
-    gm.amount = 1
-    res = await firebasedb.insert('games', gm);
-    res = await firebasedb.get('games', { amount: 67.33 });
-    res = await firebasedb.getOne('games', { amount: 1 });
-    res = await firebasedb.update('games', { userid: 'Dhoni' }, { userid: 'ABC123' });
-    res = await firebasedb.update('games', { id: 'IndVSPak' }, { amount: 1000 });
-    await firebasedb.delete('games', { type: 'free' })
-
-    res = await firebasedb.insert('games', new Game('IndVSPak1', Date.now(), 'Dhoni', 100, 'free'));
-
-    res = await firebasedb.insert('games', new Game('IndVSPak2', Date.now(), 'Dhoni', 200, 'free'));
-
-    res = await firebasedb.insert('games', new Game('IndVSPak3', Date.now(), 'Dhoni', 300, 'paid'));
+  );
 
-    res = await firebasedb.insert('games', new Game('IndVSPak4', Date.now(), 'Dhoni', 400, 'paid'));
+  console.log("Firestore DB Tests Successfull");
+  console.log(firebasedb.metrics.getStatus());
 
-    res = await firebasedb.get('games', undefined, { sort: [{ field: 'amount', order: 'desc' }] })
-
-    res = await firebasedb.get('games', undefined, { sort: [{ field: 'amount', order: 'desc' }], limit: 2, offset: 1 })
-
-    // res = await firebasedb.get('games', {type:'paid'}, { sort: [{ field: 'amount', order: 'asc' }, { field: 'timeStamp', order: 'desc' }] })
+  checkTestsCompleted();
+}
 
-    res = await firebasedb.get('games', { amount: 100 }, {
+async function testMongo() {
+  try {
+    require("../creds.json");
+  } catch (e) {
+    console.log("testMongo", "creds.json not found");
+    checkTestsCompleted();
+    return;
+  }
+  var crd = require("../creds.json");
+  var mongodb = new MongoDB(crd.mongourl, crd.mongodbname);
+  console.log(mongodb.metrics.getStatus());
+
+  if (mongodb.db == undefined) {
+    await mongodb._connect();
+  }
+  try {
+    var gm = new Game("IndVSPak", Date.now(), "Dhoni", 67.33, "free");
+    mongodb.loglevel = 1;
+    var res = await mongodb.create("games", gm);
+    res = await mongodb.insert("games", gm);
+    res = await mongodb.insert(
+      "games",
+      new Game("IndVSPak", Date.now(), "Dhoni", 67.33, "free")
+    );
+    res = await mongodb.get("games", { amount: 67.33 });
+    res = await mongodb.getOne("games", { amount: 1 });
+    res = await mongodb.update(
+      "games",
+      { userid: "Dhoni" },
+      { userid: "ABC123" }
+    );
+    res = await mongodb.update("games", { id: "IndVSPak" }, { amount: 1000 });
+
+    res = await mongodb.insert(
+      "games",
+      new Game("IndVSPak1", Date.now(), "Dhoni", 100, "free")
+    );
+
+    res = await mongodb.insert(
+      "games",
+      new Game("IndVSPak2", Date.now(), "Dhoni", 200, "free")
+    );
+
+    res = await mongodb.insert(
+      "games",
+      new Game("IndVSPak3", Date.now(), "Dhoni", 300, "paid")
+    );
+
+    res = await mongodb.insert(
+      "games",
+      new Game("IndVSPak4", Date.now(), "Dhoni", 400, "paid")
+    );
+
+    res = await mongodb.get("games", undefined, {
+      sort: [{ field: "amount", order: "desc" }],
+    });
+
+    res = await mongodb.get("games", undefined, {
+      sort: [
+        { field: "timeStamp", order: "asc" },
+        { field: "amount", order: "asc" },
+      ],
+      limit: 5,
+      offset: 1,
+    });
+
+    res = await mongodb.get(
+      "games",
+      { type: "paid" },
+      {
+        sort: [
+          { field: "amount", order: "asc" },
+          { field: "timeStamp", order: "desc" },
+        ],
+      }
+    );
+
+    res = await mongodb.get(
+      "games",
+      { amount: 400 },
+      {
         apply: {
-            field: 'timeStamp',
-            sort: 'desc',
-            ineq: {
-                op: '>=',
-                value: 1
-            }
+          field: "timeStamp",
+          sort: "desc",
+          ineq: {
+            op: ">=",
+            value: 1,
+          },
         },
-        sort: [{ field: 'amount', order: 'asc' }, { field: 'timeStamp', order: 'desc' }],
-        limit: 2, offset: 1
-    })
-
-    console.log('Firestore DB Tests Successfull')
-    console.log(firebasedb.metrics.getStatus())
-
+        sort: [
+          { field: "amount", order: "asc" },
+          { field: "timeStamp", order: "desc" },
+        ],
+        limit: 2,
+        offset: 1,
+      }
+    );
+    await mongodb.delete("games", { type: "free" });
+    console.log("Mongo DB Tests Successfull");
+    console.log(mongodb.metrics.getStatus());
+  } finally {
+    mongodb._close();
     checkTestsCompleted();
-
+  }
 }
 
-
-async function testMongo() {
-    try {
-        require('../creds.json')
-
-    } catch (e) {
-        console.log('testMongo', 'creds.json not found');
-        checkTestsCompleted();
-        return
-    }
-    var crd = require('../creds.json')
-    var mongodb = new MongoDB(crd.mongourl, crd.mongodbname);
-    console.log(mongodb.metrics.getStatus())
-
-    if (mongodb.db == undefined) {
-        await mongodb._connect();
-    }
-    try {
-        var gm = new Game('IndVSPak', Date.now(), 'Dhoni', 67.33, 'free')
-        mongodb.loglevel = 1
-        var res = await mongodb.create('games', gm);
-        res = await mongodb.insert('games', gm);
-        res = await mongodb.insert('games',
-            new Game('IndVSPak', Date.now(), 'Dhoni', 67.33, 'free'));
-        res = await mongodb.get('games', { amount: 67.33 });
-        res = await mongodb.getOne('games', { amount: 1 });
-        res = await mongodb.update('games', { userid: 'Dhoni' }, { userid: 'ABC123' });
-        res = await mongodb.update('games', { id: 'IndVSPak' }, { amount: 1000 });
-
-        res = await mongodb.insert('games', new Game('IndVSPak1', Date.now(), 'Dhoni', 100, 'free'));
-
-        res = await mongodb.insert('games', new Game('IndVSPak2', Date.now(), 'Dhoni', 200, 'free'));
-
-        res = await mongodb.insert('games', new Game('IndVSPak3', Date.now(), 'Dhoni', 300, 'paid'));
-
-        res = await mongodb.insert('games', new Game('IndVSPak4', Date.now(), 'Dhoni', 400, 'paid'));
-
-        res = await mongodb.get('games', undefined, { sort: [{ field: 'amount', order: 'desc' }] })
-
-        res = await mongodb.get('games', undefined, { sort: [{ field: 'timeStamp', order: 'asc' }, { field: 'amount', order: 'asc' }], limit: 5, offset: 1 })
-
-        res = await mongodb.get('games', { type: 'paid' }, { sort: [{ field: 'amount', order: 'asc' }, { field: 'timeStamp', order: 'desc' }] })
-
-        res = await mongodb.get('games', { amount: 400 }, {
-            apply: {
-                field: 'timeStamp',
-                sort: 'desc',
-                ineq: {
-                    op: '>=',
-                    value: 1
-                }
-            },
-            sort: [{ field: 'amount', order: 'asc' }, { field: 'timeStamp', order: 'desc' }],
-            limit: 2, offset: 1
-        })
-        await mongodb.delete('games', { type: 'free' })
-        console.log('Mongo DB Tests Successfull')
-        console.log(mongodb.metrics.getStatus())
-
-
-    } finally {
-        mongodb._close();
-        checkTestsCompleted();
-    }
-
-}
-
-
 async function testOracleDb() {
-    let creds = require('../creds/oracle/creds.json')
-    creds.wallet_dir = path.join(__dirname, '../creds/oracle')
-    var oracledb = new OracleDB(creds);
-    console.log(oracledb.metrics.getStatus())
-    var gm = new Game('IndVSPak', Date.now(), 'Dhoni', 67.33, 'paid')
-    gm.completed = true
-    gm.runs = ['a', 'b']
-    gm.extras = {
-        location: 'India',
-        raining: false,
-        match: 1
-    }
-    oracledb.loglevel = 1
-    await oracledb.connect()
-    test(oracledb)
+  let creds = require("../creds/oracle/creds.json");
+  creds.wallet_dir = path.join(__dirname, "../creds/oracle");
+  var oracledb = new OracleDB(creds);
+  console.log(oracledb.metrics.getStatus());
+  var gm = new Game("IndVSPak", Date.now(), "Dhoni", 67.33, "paid");
+  gm.completed = true;
+  gm.runs = ["a", "b"];
+  gm.extras = {
+    location: "India",
+    raining: false,
+    match: 1,
+  };
+  oracledb.loglevel = 1;
+  await oracledb.connect();
+  test(oracledb);
 }
 
-
-
 async function testMysqlDb() {
-    let creds = require('../creds/mysql.json')
-    var mysqldb = new MySQLDB(creds);
-    console.log(mysqldb.metrics.getStatus())
-    mysqldb.loglevel = 1
-    await mysqldb.connect()
-    test(mysqldb)
+  let creds = require("../creds/mysql.json");
+  var mysqldb = new MySQLDB(creds);
+  console.log(mysqldb.metrics.getStatus());
+  mysqldb.loglevel = 1;
+  await mysqldb.connect();
+  test(mysqldb);
 }
 
+async function testHanaDb() {
+  let creds = require("../creds/hana.json");
+  var hana = new HanaDB(creds);
+  console.log(hana.metrics.getStatus());
+  hana.loglevel = 1;
+  await hana.connect();
+  test(hana);
+}
 
 async function test(db) {
-    testCount++
-    var gm = new Game('IndVSPak', Date.now(), 'Dhoni', 67.33, 'paid')
-    gm.completed = true
-    gm.runs = ['a', 'b']
-    gm.extras = {
-        location: 'India',
-        raining: false,
-        match: 1
+  testCount++;
+  var gm = new Game("IndVSPak", Date.now(), "Dhoni", 67.33, "paid");
+  gm.completed = true;
+  gm.runs = ["a", "b"];
+  gm.extras = {
+    location: "India",
+    raining: false,
+    match: 1,
+  };
+  var res = await db.create("games", gm).catch((e) => {
+    if (!e.message.includes("duplicate")) {
+      throw e;
     }
-    var res = await db.create('games', gm);
-    gm.id = Date.now()
-    res = await db.insert('games', gm);
-    gm.id = Date.now()
-
-    res = await db.insert('games', gm);
-    gm.amount = 1
-    gm.id = Date.now()
-
-    res = await db.insert('games', gm);
-    res = await db.get('games', { amount: 1 });
-    res = await db.getOne('games', { amount: 1 });
-    res = await db.update('games', { amount: 1 }, { userid: 'xxxx' });
-    res = await db.getOne('games', { userid: 'xxxx' });
-
-    res = await db.insert('games', new Game('IndVSPak1', Date.now(), 'Dhoni', 100, 'free'));
-
-    res = await db.insert('games', new Game('IndVSPak2', Date.now(), 'Dhoni', 200, 'free'));
-
-    res = await db.insert('games', new Game('IndVSPak3', Date.now(), 'Dhoni', 300, 'paid'));
-
-    res = await db.insert('games', new Game('IndVSPak4', Date.now(), 'Dhoni', 400, 'paid'));
-
-    res = await db.get('games', undefined, { sort: [{ field: 'timeStamp', order: 'asc' }, { field: 'amount', order: 'asc' }], limit: 5, offset: 1 })
-
-    res = await db.get('games', { type: 'paid' }, { sort: [{ field: 'amount', order: 'desc' }, { field: 'timeStamp', order: 'desc' }] })
-
-    res = await db.get('games', { amount: 400 }, {
-        apply: {
-            field: 'timeStamp',
-            sort: 'desc',
-            ineq: {
-                op: '>=',
-                value: 1
-            }
+  });
+  gm.id = Date.now();
+  res = await db.insert("games", gm);
+  gm.id = Date.now();
+
+  res = await db.insert("games", gm);
+  gm.amount = 1;
+  gm.id = Date.now();
+
+  res = await db.insert("games", gm);
+  res = await db.get("games", { amount: 1 });
+  res = await db.getOne("games", { amount: 1 });
+  res = await db.update("games", { amount: 1 }, { userid: "xxxx" });
+  res = await db.getOne("games", { userid: "xxxx" });
+
+  res = await db.insert(
+    "games",
+    new Game("IndVSPak1", Date.now(), "Dhoni", 100, "free")
+  );
+
+  res = await db.insert(
+    "games",
+    new Game("IndVSPak2", Date.now(), "Dhoni", 200, "free")
+  );
+
+  res = await db.insert(
+    "games",
+    new Game("IndVSPak3", Date.now(), "Dhoni", 300, "paid")
+  );
+
+  res = await db.insert(
+    "games",
+    new Game("IndVSPak4", Date.now(), "Dhoni", 400, "paid")
+  );
+
+  res = await db.get("games", undefined, {
+    sort: [
+      { field: "timeStamp", order: "asc" },
+      { field: "amount", order: "asc" },
+    ],
+    limit: 5,
+    offset: 1,
+  });
+
+  res = await db.get(
+    "games",
+    { type: "paid" },
+    {
+      sort: [
+        { field: "amount", order: "desc" },
+        { field: "timeStamp", order: "desc" },
+      ],
+    }
+  );
+
+  res = await db.get(
+    "games",
+    { amount: 400 },
+    {
+      apply: {
+        field: "timeStamp",
+        sort: "desc",
+        ineq: {
+          op: ">=",
+          value: 1,
         },
-        sort: [{ field: 'amount', order: 'asc' }, { field: 'timeStamp', order: 'desc' }],
-        limit: 2, offset: 1
-    })
+      },
+      sort: [
+        { field: "amount", order: "asc" },
+        { field: "timeStamp", order: "desc" },
+      ],
+      limit: 2,
+      offset: 1,
+    }
+  );
 
-    res = await db.delete('games', { id: 'IndVSPak1' });
-    res = await db.getOne('games', { id: 'IndVSPak1' });
+  res = await db.delete("games", { id: "IndVSPak1" });
+  res = await db.getOne("games", { id: "IndVSPak1" });
 
-    console.log('SQLite DB Tests Successfull')
-    console.log(db.metrics.getStatus())
-    checkTestsCompleted();
+  console.log("SQLite DB Tests Successfull");
+  console.log(db.metrics.getStatus());
+  checkTestsCompleted();
 }
 
 // testSqlite();
 // testFireStore();
 // testMongo();
 // testOracleDb()
-testMysqlDb()
+// testMysqlDb();
+testHanaDb();