ueberdb2 4.0.11 → 4.0.15

package/databases/{elasticsearch_db.js → elasticsearch_db.ts}

@@ -1,4 +1,3 @@
-'use strict';
 /**
  * 2015 Visionist, Inc.
  *
@@ -15,17 +14,19 @@
  * limitations under the License.
  */
 
-const AbstractDatabase = require('../lib/AbstractDatabase');
-const assert = require('assert').strict;
-const {Buffer} = require('buffer');
-const crypto = require('crypto');
-const es = require('elasticsearch7');
+import AbstractDatabase, {Settings} from '../lib/AbstractDatabase';
+import {equal, strict} from 'assert';
+
+import {Buffer} from 'buffer';
+import {createHash} from 'crypto';
+import {Client} from 'elasticsearch7';
+import {BulkObject} from './cassandra_db';
 
 const schema = '2';
 
-const keyToId = (key) => {
+const keyToId = (key:string) => {
   const keyBuf = Buffer.from(key);
-  return keyBuf.length > 512 ? crypto.createHash('sha512').update(keyBuf).digest('hex') : key;
+  return keyBuf.length > 512 ? createHash('sha512').update(keyBuf).digest('hex') : key;
 };
 
 const mappings = {
@@ -37,7 +38,7 @@ const mappings = {
   },
 };
 
-const migrateToSchema2 = async (client, v1BaseIndex, v2Index, logger) => {
+const migrateToSchema2 = async (client: any, v1BaseIndex: string | undefined, v2Index: string, logger: any) => {
   let recordsMigratedLastLogged = 0;
   let recordsMigrated = 0;
   const totals = new Map();
@@ -53,13 +54,13 @@ const migrateToSchema2 = async (client, v1BaseIndex, v2Index, logger) => {
       q.push({index, res});
     }
     while (q.length) {
-      const {index, res: {hits: {hits, total: {value: total}}}} = q.shift();
+      const {index, res: {hits: {hits, total: {value: total}}}}:any = q.shift();
       if (hits.length === 0) continue;
       totals.set(index, total);
       const body = [];
       for (const {_id, _type, _source: {val}} of hits) {
         let key = `${_type}:${_id}`;
-        if (index !== v1BaseIndex) {
+        if (v1BaseIndex && index !== v1BaseIndex) {
           const parts = index.slice(v1BaseIndex.length + 1).split('-');
           if (parts.length !== 2) {
             throw new Error(`unable to migrate records from index ${index} due to data ambiguity`);
@@ -71,6 +72,7 @@ const migrateToSchema2 = async (client, v1BaseIndex, v2Index, logger) => {
       await client.bulk({index: v2Index, body});
       recordsMigrated += hits.length;
       if (Math.floor(recordsMigrated / 100) > Math.floor(recordsMigratedLastLogged / 100)) {
+        // @ts-ignore
         const total = [...totals.values()].reduce((a, b) => a + b, 0);
         logger.info(`Migrated ${recordsMigrated} records out of ${total}`);
         recordsMigratedLastLogged = recordsMigrated;
@@ -80,12 +82,17 @@ const migrateToSchema2 = async (client, v1BaseIndex, v2Index, logger) => {
     }
     logger.info(`Finished migrating ${recordsMigrated} records`);
   } finally {
+    // @ts-ignore
     await Promise.all([...scrollIds.values()].map((scrollId) => client.clearScroll({scrollId})));
   }
 };
 
-exports.Database = class extends AbstractDatabase {
-  constructor(settings) {
+export const Database = class extends AbstractDatabase {
+  private _client: any;
+  private readonly _index: any;
+  private _indexClean: boolean;
+  private readonly _q: {index: any};
+  constructor(settings:Settings) {
     super();
     this._client = null;
     this.settings = {
@@ -118,12 +125,13 @@ exports.Database = class extends AbstractDatabase {
    */
   async init() {
     // create elasticsearch client
-    const client = new es.Client({
+    const client = new Client({
       node: `http://${this.settings.host}:${this.settings.port}`,
     });
     await client.ping();
     if (!(await client.indices.exists({index: this._index})).body) {
       let tmpIndex;
+      // @ts-ignore
       const {body: migrate} = await client.indices.exists({index: this.settings.base_index});
       if (migrate && !this.settings.migrate_to_newer_schema) {
         throw new Error(
@@ -141,8 +149,9 @@ exports.Database = class extends AbstractDatabase {
       await client.indices.putAlias({index: tmpIndex, name: this._index});
     }
     const indices = Object.values((await client.indices.get({index: this._index})).body);
-    assert.equal(indices.length, 1);
+    equal(indices.length, 1);
     try {
+      // @ts-ignore
       assert.deepEqual(indices[0].mappings, mappings);
     } catch (err) {
       this.logger.warn(`Index ${this._index} mappings does not match expected; ` +
@@ -156,7 +165,7 @@ exports.Database = class extends AbstractDatabase {
    *
    *  @param {String} key Key
    */
-  async get(key) {
+  async get(key:string) {
     const {body} = await this._client.get({...this._q, id: keyToId(key)}, {ignore: [404]});
     if (!body.found) return null;
     return body._source.value;
@@ -166,7 +175,7 @@ exports.Database = class extends AbstractDatabase {
    *  @param key Search key, which uses an asterisk (*) as the wild card.
    *  @param notKey Used to filter the result set
    */
-  async findKeys(key, notKey) {
+  async findKeys(key:string, notKey:string) {
     await this._refreshIndex();
     const q = {
       ...this._q,
@@ -182,7 +191,7 @@ exports.Database = class extends AbstractDatabase {
       },
     };
     const {body: {hits: {hits}}} = await this._client.search(q);
-    return hits.map((h) => h._source.key);
+    return hits.map((h:{_source:{key:string}}) => h._source.key);
   }
 
   /**
@@ -191,7 +200,7 @@ exports.Database = class extends AbstractDatabase {
    *  @param {String} key Record identifier.
    *  @param {JSON|String} value The value to store in the database.
    */
-  async set(key, value) {
+  async set(key: string, value:string) {
     this._indexClean = false;
     await this._client.index({...this._q, id: keyToId(key), body: {key, value}});
   }
@@ -204,7 +213,7 @@ exports.Database = class extends AbstractDatabase {
    *
    *  @param {String} key Record identifier.
    */
-  async remove(key) {
+  async remove(key:string) {
     this._indexClean = false;
     await this._client.delete({...this._q, id: keyToId(key)}, {ignore: [404]});
   }
@@ -218,7 +227,7 @@ exports.Database = class extends AbstractDatabase {
    *  @param {Array} bulk An array of JSON data in the format:
    *      {"type":type, "key":key, "value":value}
    */
-  async doBulk(bulk) {
+  async doBulk(bulk: BulkObject[]) {
     // bulk is an array of JSON:
     // example: [{"type":"set", "key":"sessionstorage:{id}", "value":{"cookie":{...}}]
 

package/databases/{memory_db.js → memory_db.ts}

@@ -1,9 +1,9 @@
-'use strict';
+import AbstractDatabase, {Settings} from '../lib/AbstractDatabase';
 
-const AbstractDatabase = require('../lib/AbstractDatabase');
 
-exports.Database = class extends AbstractDatabase {
-  constructor(settings) {
+export const Database = class MemoryDB extends AbstractDatabase {
+  private _data: any;
+  constructor(settings:Settings) {
     super();
     this.settings = settings;
     settings.json = false;
@@ -18,12 +18,12 @@ exports.Database = class extends AbstractDatabase {
     this._data = null;
   }
 
-  findKeys(key, notKey) {
+  findKeys(key:string, notKey:string) {
     const regex = this.createFindRegex(key, notKey);
     return [...this._data.keys()].filter((k) => regex.test(k));
   }
 
-  get(key) {
+  get(key:string) {
     return this._data.get(key);
   }
 
@@ -31,11 +31,11 @@ exports.Database = class extends AbstractDatabase {
     this._data = this.settings.data || new Map();
   }
 
-  remove(key) {
+  remove(key:string) {
     this._data.delete(key);
   }
 
-  set(key, value) {
+  set(key:string, value:string) {
     this._data.set(key, value);
   }
 };

package/databases/mock_db.ts

@@ -0,0 +1,43 @@
+import {Settings} from '../lib/AbstractDatabase';
+
+import events from 'events';
+
+export const Database = class extends events.EventEmitter {
+  private settings: Settings;
+  constructor(settings:Settings) {
+    super();
+    this.settings = {
+      writeInterval: 1,
+      ...settings,
+    };
+    settings.mock = this;
+  }
+
+  close(cb: ()=>{}) {
+    this.emit('close', cb);
+  }
+
+  doBulk(ops:string, cb: ()=>{}) {
+    this.emit('doBulk', ops, cb);
+  }
+
+  findKeys(key:string, notKey:string, cb:()=>{}) {
+    this.emit('findKeys', key, notKey, cb);
+  }
+
+  get(key:string, cb:()=>{}) {
+    this.emit('get', key, cb);
+  }
+
+  init(cb:()=>{}) {
+    this.emit('init', cb);
+  }
+
+  remove(key:string, cb:()=>{}) {
+    this.emit('remove', key, cb);
+  }
+
+  set(key:string, value:string, cb:()=>{}) {
+    this.emit('set', key, value, cb);
+  }
+};

package/databases/{mongodb_db.js → mongodb_db.ts}

@@ -1,4 +1,3 @@
-'use strict';
 /**
  * 2020 Sylchauf
  *
@@ -15,10 +14,16 @@
  * limitations under the License.
  */
 
-const AbstractDatabase = require('../lib/AbstractDatabase');
+import AbstractDatabase, {Settings} from '../lib/AbstractDatabase';
+import {Func} from 'mocha';
+import {BulkObject} from './cassandra_db';
 
 exports.Database = class extends AbstractDatabase {
-  constructor(settings) {
+  private interval: any;
+  private database: any;
+  private client: any;
+  private collection: any;
+  constructor(settings:Settings) {
     super();
     this.settings = settings;
 
@@ -44,10 +49,10 @@ exports.Database = class extends AbstractDatabase {
     }, 10000);
   }
 
-  init(callback) {
+  init(callback:Function) {
     const MongoClient = require('mongodb').MongoClient;
 
-    MongoClient.connect(this.settings.url, (err, client) => {
+    MongoClient.connect(this.settings.url, (err:any, client:any) => {
       if (!err) {
         this.client = client;
         this.database = client.db(this.settings.database);
@@ -60,8 +65,8 @@ exports.Database = class extends AbstractDatabase {
     this.schedulePing();
   }
 
-  get(key, callback) {
-    this.collection.findOne({_id: key}, (err, document) => {
+  get(key:string, callback:Function) {
+    this.collection.findOne({_id: key}, (err:any, document:any) => {
       if (err) callback(err);
       else callback(null, document ? document.value : null);
     });
@@ -69,7 +74,7 @@ exports.Database = class extends AbstractDatabase {
     this.schedulePing();
   }
 
-  findKeys(key, notKey, callback) {
+  findKeys(key:string, notKey:string, callback:Function) {
     const selector = {
       $and: [
         {_id: {$regex: `${key.replace(/\*/g, '')}`}},
@@ -77,23 +82,24 @@ exports.Database = class extends AbstractDatabase {
     };
 
     if (notKey) {
+      // @ts-ignore
       selector.$and.push({_id: {$not: {$regex: `${notKey.replace(/\*/g, '')}`}}});
     }
 
-    this.collection.find(selector, async (err, res) => {
+    this.collection.find(selector, async (err:any, res:any) => {
       if (err) {
         callback(err);
       } else {
         const data = await res.toArray();
 
-        callback(null, data.map((i) => i._id));
+        callback(null, data.map((i:any) => i._id));
       }
     });
 
     this.schedulePing();
   }
 
-  set(key, value, callback) {
+  set(key:string, value:string, callback:Function) {
     if (key.length > 100) {
       callback('Your Key can only be 100 chars');
     } else {
@@ -103,13 +109,13 @@ exports.Database = class extends AbstractDatabase {
     this.schedulePing();
   }
 
-  remove(key, callback) {
+  remove(key:string, callback:Function) {
     this.collection.remove({_id: key}, callback);
 
     this.schedulePing();
   }
 
-  doBulk(bulk, callback) {
+  doBulk(bulk:BulkObject[], callback:Function) {
     const bulkMongo = this.collection.initializeOrderedBulkOp();
 
     for (const i in bulk) {
@@ -120,16 +126,16 @@ exports.Database = class extends AbstractDatabase {
       }
     }
 
-    bulkMongo.execute().then((res) => {
+    bulkMongo.execute().then((res:any) => {
       callback(null, res);
-    }).catch((error) => {
+    }).catch((error:any) => {
       callback(error);
     });
 
     this.schedulePing();
   }
 
-  close(callback) {
+  close(callback:any) {
     this.clearPing();
     this.client.close(callback);
   }

package/databases/{mssql_db.js → mssql_db.ts}

@@ -1,4 +1,3 @@
-'use strict';
 /* eslint new-cap: ["error", {"capIsNewExceptions": ["mssql.NVarChar"]}] */
 
 /**
@@ -21,12 +20,19 @@
  *
  */
 
-const AbstractDatabase = require('../lib/AbstractDatabase');
-const async = require('async');
-const mssql = require('mssql');
+import AbstractDatabase, {Settings} from '../lib/AbstractDatabase';
+import async from 'async';
+import mssql, {ConnectionPool} from 'mssql';
+import {BulkObject} from './cassandra_db';
 
-exports.Database = class extends AbstractDatabase {
-  constructor(settings) {
+type RowResult = {
+    key: string;
+};
+
+
+export const Database = class MSSQL extends AbstractDatabase {
+  private db: ConnectionPool | undefined;
+  constructor(settings:Settings) {
     super();
     settings = settings || {};
 
@@ -49,7 +55,7 @@ exports.Database = class extends AbstractDatabase {
     this.settings.writeInterval = 0;
   }
 
-  init(callback) {
+  init(callback:(err: any)=>{}) {
     const sqlCreate =
         "IF OBJECT_ID(N'dbo.store', N'U') IS NULL" +
         '  BEGIN' +
@@ -59,6 +65,7 @@ exports.Database = class extends AbstractDatabase {
         '    );' +
         '  END';
 
+    // @ts-ignore
     new mssql.ConnectionPool(this.settings).connect().then((pool) => {
       this.db = pool;
 
@@ -74,7 +81,7 @@ exports.Database = class extends AbstractDatabase {
     });
   }
 
-  get(key, callback) {
+  get(key:string, callback:(err?:Error, value?:string)=>{}) {
     const request = new mssql.Request(this.db);
 
     request.input('key', mssql.NVarChar(100), key);
@@ -82,7 +89,8 @@ exports.Database = class extends AbstractDatabase {
     request.query('SELECT [value] FROM [store] WHERE [key] = @key', (err, results) => {
       let value = null;
 
-      if (!err && results.rowsAffected[0] === 1) {
+      if (!err && results && results.rowsAffected[0] === 1) {
+        // @ts-ignore
         value = results.recordset[0].value;
       }
 
@@ -90,7 +98,7 @@ exports.Database = class extends AbstractDatabase {
     });
   }
 
-  findKeys(key, notKey, callback) {
+  findKeys(key:string, notKey:string, callback:(err: Error | undefined, value:string[])=>{}) {
     const request = new mssql.Request(this.db);
     let query = 'SELECT [key] FROM [store] WHERE [key] LIKE @key';
 
@@ -107,11 +115,11 @@ exports.Database = class extends AbstractDatabase {
     }
 
     request.query(query, (err, results) => {
-      const value = [];
+      const value:string[] = [];
 
-      if (!err && results.rowsAffected[0] > 0) {
+      if (!err && results && results.rowsAffected[0] > 0) {
         for (let i = 0; i < results.recordset.length; i++) {
-          value.push(results.recordset[i].key);
+          value.push((results.recordset[i] as RowResult).key);
         }
       }
 
@@ -119,7 +127,7 @@ exports.Database = class extends AbstractDatabase {
     });
   }
 
-  set(key, value, callback) {
+  set(key:string, value:string, callback: (val:string)=>{}) {
     const request = new mssql.Request(this.db);
 
     if (key.length > 100) {
@@ -135,23 +143,23 @@ exports.Database = class extends AbstractDatabase {
       request.input('value', mssql.NText, value);
 
       request.query(query, (err, info) => {
-        callback(err);
+        callback(err ? err.toString() : '');
       });
     }
   }
 
-  remove(key, callback) {
+  remove(key:string, callback:()=>{}) {
     const request = new mssql.Request(this.db);
     request.input('key', mssql.NVarChar(100), key);
     request.query('DELETE FROM [store] WHERE [key] = @key', callback);
   }
 
-  doBulk(bulk, callback) {
+  doBulk(bulk: BulkObject[], callback:(err:any, results?: any)=>{}) {
     const maxInserts = 100;
     const request = new mssql.Request(this.db);
     let firstReplace = true;
     let firstRemove = true;
-    const replacements = [];
+    const replacements: string[] = [];
     let removeSQL = 'DELETE FROM [store] WHERE [key] IN (';
 
     for (const i in bulk) {
@@ -159,7 +167,7 @@ exports.Database = class extends AbstractDatabase {
         if (firstReplace) {
           replacements.push('BEGIN TRANSACTION;');
           firstReplace = false;
-        } else if (i % maxInserts === 0) {
+        } else if (Number(i) % maxInserts === 0) {
           replacements.push('\nCOMMIT TRANSACTION;\nBEGIN TRANSACTION;\n');
         }
 
@@ -212,7 +220,7 @@ exports.Database = class extends AbstractDatabase {
     );
   }
 
-  close(callback) {
-    this.db.close(callback);
+  close(callback: (err?:Error)=>{}) {
+    this.db && this.db.close(callback);
   }
 };

package/databases/{mysql_db.js → mysql_db.ts}

@@ -1,4 +1,3 @@
-'use strict';
 /**
  * 2011 Peter 'Pita' Martischka
  *
@@ -15,12 +14,15 @@
  * limitations under the License.
  */
 
-const AbstractDatabase = require('../lib/AbstractDatabase');
-const mysql = require('mysql');
-const util = require('util');
+import AbstractDatabase, {Settings} from '../lib/AbstractDatabase';
+import mysql from 'mysql';
+import util from 'util';
+import {BulkObject} from './cassandra_db';
 
-exports.Database = class extends AbstractDatabase {
-  constructor(settings) {
+export const Database = class extends AbstractDatabase {
+  private _mysqlSettings: Settings;
+  private _pool: any;
+  constructor(settings:Settings) {
     super();
     this.logger = console;
     this._mysqlSettings = {
@@ -39,19 +41,21 @@ exports.Database = class extends AbstractDatabase {
 
   get isAsync() { return true; }
 
-  async _query(options) {
+  async _query(options: any):Promise<any> {
     try {
       return await new Promise((resolve, reject) => {
         options = {timeout: this.settings.queryTimeout, ...options};
-        this._pool.query(options, (err, ...args) => err != null ? reject(err) : resolve(args));
+        // @ts-ignore
+        this._pool && this._pool.query(options, (err, ...args) => err != null ? reject(err) : resolve(args));
       });
-    } catch (err) {
+    } catch (err:any) {
       this.logger.error(`${err.fatal ? 'Fatal ' : ''}MySQL error: ${err.stack || err}`);
       throw err;
     }
   }
 
   async init() {
+    // @ts-ignore
     this._pool = mysql.createPool(this._mysqlSettings);
     const {database, charset} = this._mysqlSettings;
 
@@ -69,6 +73,7 @@ exports.Database = class extends AbstractDatabase {
     const dbCharSet =
         'SELECT DEFAULT_CHARACTER_SET_NAME, DEFAULT_COLLATION_NAME ' +
         `FROM INFORMATION_SCHEMA.SCHEMATA WHERE SCHEMA_NAME = '${database}'`;
+    // @ts-ignore
     let [result] = await this._query({sql: dbCharSet});
 
     result = JSON.parse(JSON.stringify(result));
@@ -112,7 +117,7 @@ exports.Database = class extends AbstractDatabase {
     }
   }
 
-  async get(key) {
+  async get(key:string) {
     const [results] = await this._query({
       sql: 'SELECT `value` FROM `store` WHERE `key` = ? AND BINARY `key` = ?',
       values: [key, key],
@@ -120,7 +125,7 @@ exports.Database = class extends AbstractDatabase {
     return results.length === 1 ? results[0].value : null;
   }
 
-  async findKeys(key, notKey) {
+  async findKeys(key:string, notKey:string) {
     let query = 'SELECT `key` FROM `store` WHERE `key` LIKE ?';
     const params = [];
 
@@ -135,22 +140,22 @@ exports.Database = class extends AbstractDatabase {
       params.push(notKey);
     }
     const [results] = await this._query({sql: query, values: params});
-    return results.map((val) => val.key);
+    return results.map((val:{key:string}) => val.key);
   }
 
-  async set(key, value) {
+  async set(key:string, value:string) {
     if (key.length > 100) throw new Error('Your Key can only be 100 chars');
     await this._query({sql: 'REPLACE INTO `store` VALUES (?,?)', values: [key, value]});
   }
 
-  async remove(key) {
+  async remove(key:string) {
     await this._query({
       sql: 'DELETE FROM `store` WHERE `key` = ? AND BINARY `key` = ?',
       values: [key, key],
     });
   }
 
-  async doBulk(bulk) {
+  async doBulk(bulk:BulkObject[]) {
     const replaces = [];
     const deletes = [];
     for (const op of bulk) {