ueberdb2 4.0.10 → 4.0.15

package/{index.js → index.ts}

@@ -17,28 +17,50 @@
  * limitations under the License.
  */
 
-const cacheAndBufferLayer = require('./lib/CacheAndBufferLayer');
-const logging = require('./lib/logging');
-const util = require('util');
-
-const cbDb = {};
+// @ts-ignore
+import cacheAndBufferLayer from './lib/CacheAndBufferLayer';
+import {normalizeLogger} from './lib/logging';
+import {callbackify} from 'util';
+import {Settings} from './lib/AbstractDatabase';
+
+const cbDb = {
+  init: () => {},
+  flush: () => {},
+  get: () => {},
+  remove: () => {},
+  findKeys: () => {},
+  close: () => {},
+  getSub: () => {},
+  setSub: () => {},
+};
 const fns = ['close', 'findKeys', 'flush', 'get', 'getSub', 'init', 'remove', 'set', 'setSub'];
-for (const fn of fns) cbDb[fn] = util.callbackify(cacheAndBufferLayer.Database.prototype[fn]);
-
-const makeDoneCallback = (callback, deprecated) => (err) => {
+for (const fn of fns) { // @ts-ignore
+  cbDb[fn] = callbackify(cacheAndBufferLayer.Database.prototype[fn]);
+}
+const makeDoneCallback = (callback: (err?:any)=>{}, deprecated:(err:any)=>{}) => (err: null) => {
   if (callback) callback(err);
   if (deprecated) deprecated(err);
   if (err != null && callback == null && deprecated == null) throw err;
 };
 
-exports.Database = class {
+export const Database = class {
+  private type: any;
+  private dbModule: any;
+  private readonly dbSettings: any;
+  private readonly wrapperSettings: any | {};
+  private readonly logger: Function | null;
+  private readonly db: any;
+  private metrics: any;
   /**
+   * @param type The type of the database
+   * @param dbSettings The settings for that specific database type
+   * @param wrapperSettings
    * @param logger Optional logger object. If no logger object is provided no logging will occur.
    *     The logger object is expected to be a log4js logger object or `console`. A logger object
    *     from another logging library should also work, but performance may be reduced if the logger
    *     object does not have is${Level}Enabled() methods (isDebugEnabled(), etc.).
    */
-  constructor(type, dbSettings, wrapperSettings, logger = null) {
+  constructor(type: undefined | string, dbSettings: Settings | null | string, wrapperSettings?: null | {}, logger:any = null) {
     if (!type) {
       type = 'sqlite';
       dbSettings = null;
@@ -50,7 +72,7 @@ exports.Database = class {
     this.dbModule = require(`./databases/${type}_db`);
     this.dbSettings = dbSettings;
     this.wrapperSettings = wrapperSettings;
-    this.logger = logging.normalizeLogger(logger);
+    this.logger = normalizeLogger(logger);
     const db = new this.dbModule.Database(this.dbSettings);
     db.logger = this.logger;
     this.db = new cacheAndBufferLayer.Database(db, this.wrapperSettings, this.logger);
@@ -66,7 +88,9 @@ exports.Database = class {
    * @param callback - Deprecated. Node-style callback. If null, a Promise is returned.
    */
   init(callback = null) {
-    if (callback != null) return cbDb.init.call(this.db, callback);
+    if (callback != null) {
+      return cbDb.init.call(this.db);
+    }
     return this.db.init();
   }
 
@@ -89,67 +113,92 @@ exports.Database = class {
    * @param callback - Deprecated. Node-style callback. If null, a Promise is returned.
    */
   flush(callback = null) {
-    if (callback != null) return cbDb.flush.call(this.db, callback);
+    if (!cbDb || !cbDb.flush === undefined) return null;
+    if (callback != null) { // @ts-ignore
+      return cbDb.flush.call(this.db, callback);
+    }
     return this.db.flush();
   }
 
   /**
+   * @param key
    * @param callback - Deprecated. Node-style callback. If null, a Promise is returned.
    */
-  get(key, callback = null) {
-    if (callback != null) return cbDb.get.call(this.db, key, callback);
+  get(key:string, callback = null) {
+    if (callback != null) { // @ts-ignore
+      return cbDb.get.call(this.db, key, callback);
+    }
     return this.db.get(key);
   }
 
   /**
+   * @param key
+   * @param notKey
    * @param callback - Deprecated. Node-style callback. If null, a Promise is returned.
    */
-  findKeys(key, notKey, callback = null) {
-    if (callback != null) return cbDb.findKeys.call(this.db, key, notKey, callback);
+  findKeys(key:string, notKey:string, callback = null) {
+    if (callback != null) { // @ts-ignore
+      return cbDb.findKeys.call(this.db, key, notKey, callback);
+    }
     return this.db.findKeys(key, notKey);
   }
 
   /**
    * Removes an entry from the database if present.
    *
+   * @param key
    * @param cb Deprecated. Node-style callback. Called when the write has been committed to the
    *     underlying database driver. If null, a Promise is returned.
    * @param deprecated Deprecated callback that is called just after cb. Ignored if cb is null.
    */
-  remove(key, cb = null, deprecated = null) {
-    if (cb != null) return cbDb.remove.call(this.db, key, makeDoneCallback(cb, deprecated));
+  remove(key:string, cb = null, deprecated = null) {
+    if (cb != null) { // @ts-ignore
+      return cbDb.remove.call(this.db, key, makeDoneCallback(cb, deprecated));
+    }
     return this.db.remove(key);
   }
 
   /**
    * Adds or changes the value of an entry.
    *
+   * @param key
+   * @param value
    * @param cb Deprecated. Node-style callback. Called when the write has been committed to the
    *     underlying database driver. If null, a Promise is returned.
    * @param deprecated Deprecated callback that is called just after cb. Ignored if cb is null.
    */
-  set(key, value, cb = null, deprecated = null) {
-    if (cb != null) return cbDb.set.call(this.db, key, value, makeDoneCallback(cb, deprecated));
+  set(key:string, value:string, cb = null, deprecated = null) {
+    if (cb != null) { // @ts-ignore
+      return cbDb.get.call(this.db, key, value, makeDoneCallback(cb, deprecated));
+    }
     return this.db.set(key, value);
   }
 
   /**
+   * @param key
+   * @param sub
    * @param callback - Deprecated. Node-style callback. If null, a Promise is returned.
    */
-  getSub(key, sub, callback = null) {
-    if (callback != null) return cbDb.getSub.call(this.db, key, sub, callback);
+  getSub(key:string, sub:string, callback = null) {
+    if (callback != null) { // @ts-ignore
+      return cbDb.getSub.call(this.db, key, sub, callback);
+    }
     return this.db.getSub(key, sub);
   }
 
   /**
    * Adds or changes a subvalue of an entry.
    *
+   * @param key
+   * @param sub
+   * @param value
    * @param cb Deprecated. Node-style callback. Called when the write has been committed to the
    *     underlying database driver. If null, a Promise is returned.
    * @param deprecated Deprecated callback that is called just after cb. Ignored if cb is null.
    */
-  setSub(key, sub, value, cb = null, deprecated = null) {
+  setSub(key:string, sub:string, value:string, cb = null, deprecated = null) {
     if (cb != null) {
+      // @ts-ignore
       return cbDb.setSub.call(this.db, key, sub, value, makeDoneCallback(cb, deprecated));
     }
     return this.db.setSub(key, sub, value);
@@ -162,7 +211,9 @@ exports.Database = class {
    * @param callback - Deprecated. Node-style callback. If null, a Promise is returned.
    */
   close(callback = null) {
-    if (callback != null) return cbDb.close.call(this.db, callback);
+    if (callback != null) { // @ts-ignore
+      return cbDb.close.call(this.db, callback);
+    }
     return this.db.close();
   }
 };

package/lib/AbstractDatabase.ts

@@ -0,0 +1,79 @@
+import {normalizeLogger} from './logging';
+
+const nullLogger = normalizeLogger(null);
+
+// Format: All characters match themselves except * matches any zero or more characters. No
+// backslash escaping is supported, so it is impossible to create a pattern that matches only the
+// '*' character.
+const simpleGlobToRegExp = (s:string) => s.replace(/[.+?^${}()|[\]\\]/g, '\\$&').replace(/\*/g, '.*');
+
+export type Settings = {
+  data?: any;
+  table?: string;
+  db?: string;
+  idleTimeoutMillis?: any;
+  min?: any;
+  max?: any;
+  engine?: string;
+  charset?: string;
+  server?: string | undefined;
+  requestTimeout?: number;
+  bulkLimit?: number;
+  queryTimeout?: number;
+  connectionString?: string;
+  parseJSON?: boolean;
+  dbName?: string;
+  collection?: string;
+  url?: string;
+  mock?: any;
+  base_index?: string;
+  migrate_to_newer_schema?: boolean;
+  api?: string
+  filename?: string;
+  database?: string;
+  password?: string;
+  user?: string;
+  port?: number | string;
+  host?: string;
+  maxListeners?: number | undefined;
+  json?: boolean;
+  cache?: number;
+  writeInterval?: number;
+  logger?: any;
+  columnFamily?: any;
+  clientOptions?: any;
+};
+
+
+class AbstractDatabase {
+  logger: any;
+  // @ts-ignore
+  settings: Settings;
+  constructor() {
+    if (new.target === module.exports) {
+      throw new TypeError('cannot instantiate Abstract Database directly');
+    }
+    for (const fn of ['init', 'close', 'get', 'findKeys', 'remove', 'set']) {
+      // @ts-ignore
+      if (typeof this[fn] !== 'function') throw new TypeError(`method ${fn} not defined`);
+    }
+    this.logger = nullLogger;
+  }
+
+  /**
+   * For findKey regex. Used by document dbs like mongodb or dirty.
+   */
+  createFindRegex(key:string, notKey?:string) {
+    let regex = `^(?=${simpleGlobToRegExp(key)}$)`;
+    if (notKey != null) regex += `(?!${simpleGlobToRegExp(notKey)}$)`;
+    return new RegExp(regex);
+  }
+
+  doBulk(operations:any, cb: ()=>{}) {
+    throw new Error('the doBulk method must be implemented if write caching is enabled');
+  }
+
+  get isAsync() { return false; }
+}
+
+export default AbstractDatabase;

package/lib/{CacheAndBufferLayer.js → CacheAndBufferLayer.ts}

@@ -1,4 +1,5 @@
-'use strict';
+// @ts-nocheck
+
 /**
  * 2011 Peter 'Pita' Martischka
  *
@@ -116,20 +117,20 @@ class SelfContainedPromise extends Promise {
 }
 
 const defaultSettings =
-{
-  // Maximum number of operations that can be passed to the wrapped database's doBulk() method.
-  // Falsy means no limit. EXPERIMENTAL.
-  bulkLimit: 0,
-  // the number of elements that should be cached. To Disable cache just set it to zero
-  cache: 10000,
-  // the interval in ms the wrapper writes to the database. To Disable interval writes just set it
-  // to zero
-  writeInterval: 100,
-  // a flag if the data sould be serialized/deserialized to json
-  json: true,
-  // use utf8mb4 as default
-  charset: 'utf8mb4',
-};
+    {
+      // Maximum number of operations that can be passed to the wrapped database's doBulk() method.
+      // Falsy means no limit. EXPERIMENTAL.
+      bulkLimit: 0,
+      // the number of elements that should be cached. To Disable cache just set it to zero
+      cache: 10000,
+      // the interval in ms the wrapper writes to the database. To Disable interval writes just set it
+      // to zero
+      writeInterval: 100,
+      // a flag if the data sould be serialized/deserialized to json
+      json: true,
+      // use utf8mb4 as default
+      charset: 'utf8mb4',
+    };
 
 exports.Database = class {
   /**
@@ -316,7 +317,7 @@ exports.Database = class {
         ++this.metrics.readsFromCache;
         if (this.logger.isDebugEnabled()) {
           this.logger.debug(`GET    - ${key} - ${JSON.stringify(entry.value)} - ` +
-                            `from ${entry.dirty ? 'dirty buffer' : 'cache'}`);
+              `from ${entry.dirty ? 'dirty buffer' : 'cache'}`);
         }
         return entry.value;
       }

package/lib/{logging.js → logging.ts}

@@ -1,7 +1,5 @@
-'use strict';
-
-const {Console} = require('console');
-const {stdout, stderr} = require('process');
+import {Console} from 'console';
+import {stdout, stderr} from 'process';
 
 class ConsoleLogger extends Console {
   constructor(opts = {}) { super({stdout, stderr, inspectOptions: {depth: Infinity}, ...opts}); }
@@ -11,19 +9,25 @@ class ConsoleLogger extends Console {
   isErrorEnabled() { return true; }
 }
 
-exports.ConsoleLogger = ConsoleLogger;
 
-exports.normalizeLogger = (logger) => {
+export const normalizeLogger = (logger: null | Function) => {
   const logLevelsUsed = ['debug', 'info', 'warn', 'error'];
   logger = Object.create(logger || {});
   for (const level of logLevelsUsed) {
     const enabledFnName = `is${level.charAt(0).toUpperCase() + level.slice(1)}Enabled`;
+    // @ts-ignore
     if (typeof logger[level] !== 'function') {
+      // @ts-ignore
       logger[level] = () => {};
+      // @ts-ignore
       logger[enabledFnName] = () => false;
+      // @ts-ignore
     } else if (typeof logger[enabledFnName] !== 'function') {
+      // @ts-ignore
       logger[enabledFnName] = () => true;
     }
   }
   return logger;
 };
+
+export default {ConsoleLogger};

package/package.json

@@ -25,6 +25,7 @@
     "cassandra-driver": "^4.6.4",
     "dirty": "^1.1.3",
     "elasticsearch7": "npm:@elastic/elasticsearch@^7.17.0",
+    "eslint-plugin-import": "^2.26.0",
     "mongodb": "^3.7.3",
     "mssql": "^9.1.1",
     "mysql": "2.18.1",
@@ -39,11 +40,21 @@
     "sqlite3": "^5.1.6"
   },
   "devDependencies": {
+    "@types/async": "^3.2.20",
+    "@types/mocha": "^10.0.1",
+    "@types/mongodb": "^4.0.7",
+    "@types/mssql": "^8.1.2",
+    "@types/mysql": "^2.15.21",
+    "@types/node": "^20.3.2",
+    "@types/pg": "^8.10.2",
+    "@types/rethinkdb": "^2.3.17",
     "cli-table": "^0.3.11",
     "eslint": "^8.43.0",
     "eslint-config-etherpad": "^3.0.13",
     "mocha": "^10.2.0",
     "randexp": "^0.5.3",
+    "ts-migrate": "^0.1.35",
+    "ts-node": "^10.9.1",
     "typescript": "^4.9.5",
     "wtfnode": "^0.9.1"
   },
@@ -51,8 +62,8 @@
     "type": "git",
     "url": "https://github.com/ether/ueberDB.git"
   },
-  "main": "./index",
-  "version": "4.0.10",
+  "main": "./dist/index",
+  "version": "4.0.15",
   "bugs": {
     "url": "https://github.com/ether/ueberDB/issues"
   },
@@ -60,7 +71,10 @@
   "scripts": {
     "lint": "eslint .",
     "lint:fix": "eslint --fix .",
-    "test": "mocha test/test*.js"
+    "test": "tsc && mocha ./dist/test/test*.js",
+    "test:watch": "mocha ./dist/test/test*.js --watch",
+    "test-debug": "tsc && mocha --inspect-brk ./dist/test/test*.js",
+    "build": "tsc"
   },
   "_npmUser": {
     "name": "johnyma22",

package/test/lib/{databases.js → databases.ts}

@@ -1,9 +1,10 @@
-'use strict';
+const os = require('os');
 
-exports.databases = {
+
+export const databases = {
   memory: {},
   dirty: {
-    filename: '/tmp/ueberdb-test.db',
+    filename: `${os.tmpdir()}/ueberdb-test.db`,
     speeds: {
       setMax: 1,
       getMax: 0.1,
@@ -11,7 +12,7 @@ exports.databases = {
     },
   },
   sqlite: {
-    filename: '/tmp/ueberdb-test.sqlite',
+    filename: `${os.tmpdir()}/ueberdb-test.sqlite`,
     speeds: {
       setMax: 0.6,
       getMax: 0.5,
@@ -65,6 +66,8 @@ exports.databases = {
     base_index: 'ueberdb_test',
     speeds: {
       findKeysMax: 30,
-    },
+    }, host: '127.0.0.1',
+    port: '9200',
+
   },
 };