ueberdb2 4.0.11 → 4.0.17

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.11",
+  "main": "./dist/index",
+  "version": "4.0.17",
   "bugs": {
     "url": "https://github.com/ether/ueberDB/issues"
   },
@@ -60,7 +71,11 @@
   "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",
+    "publish": "npm run build && npm publish"
   },
   "_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',
+
   },
 };

package/test/test.ts

@@ -0,0 +1,328 @@
+// @ts-expect-error TS(7016): Could not find a declaration file for module 'wtfn... Remove this comment to see the full error message
+import wtfnode from 'wtfnode';
+// @ts-expect-error TS(7016): Could not find a declaration file for module 'cli-... Remove this comment to see the full error message
+import Clitable from 'cli-table';
+// @ts-ignore
+import Randexp from 'randexp';
+import assert$0 from 'assert';
+import {databases as databases$0} from './lib/databases';
+import {promises} from 'fs';
+import logging from '../lib/logging';
+import * as ueberdb from '../index';
+'use strict';
+const assert = assert$0.strict;
+const databases = {databases: databases$0}.databases;
+const fs = {promises}.promises;
+const maxKeyLength = 100;
+const randomString = (length = maxKeyLength) => new Randexp(new RegExp(`.{${length}}`)).gen();
+// eslint-disable-next-line mocha/no-top-level-hooks
+after(async () => {
+  // Add a timeout to forcibly exit if something is keeping node from exiting cleanly.
+  // The timeout is unref()ed so that it doesn't prevent node from exiting when done.
+  setTimeout(() => {
+    console.error('node should have exited by now but something is keeping it open ' +
+            'such as an open connection or active timer');
+    wtfnode.dump();
+    process.exit(1); // eslint-disable-line n/no-process-exit
+  }, 5000).unref();
+});
+
+describe(__filename, () => {
+  let speedTable: any;
+  let db: any;
+  before(async () => {
+    speedTable = new Clitable({
+      head: [
+        'Database',
+        'read cache',
+        'write buffer',
+        '#',
+        'ms/set',
+        'ms/get',
+        'ms/findKeys',
+        'ms/remove',
+        'total ms',
+        'total ms/#',
+      ],
+      colWidths: [15, 15, 15, 8, 13, 13, 13, 13, 13, 13],
+    });
+  });
+  after(async () => {
+    console.log(speedTable.toString());
+  });
+  Object.keys(databases).filter((v)=>v === "sqlite")
+      .forEach((database) => {
+    // @ts-ignore
+    const dbSettings = databases[database];
+    describe(database, () => {
+      for (const readCache of [false, true]) {
+        describe(`${readCache ? '' : 'no '}read cache`, () => {
+          for (const writeBuffer of [false, true]) {
+            describe(`${writeBuffer ? '' : 'no '}write buffer`, function (this: any) {
+              this.timeout(5000);
+              before(async () => {
+                if (dbSettings.filename) { await fs.unlink(dbSettings.filename).catch(() => { }); }
+                db = new ueberdb.Database(database, dbSettings, {
+                  ...(readCache ? {} : {cache: 0}),
+                  ...(writeBuffer ? {} : {writeInterval: 0}),
+                }, new logging.ConsoleLogger());
+                await db.init();
+              });
+              after(async () => {
+                await db.close();
+                if (dbSettings.filename) { await fs.unlink(dbSettings.filename).catch(() => { }); }
+              });
+              describe('white space in key is not ignored', () => {
+                for (const space of [false, true]) {
+                  describe(`key ${space ? 'has' : 'does not have'} a trailing space`, () => {
+                    let input: any;
+                    let key: any;
+                    before(async () => {
+                      input = {a: 1, b: new Randexp(/.+/).gen()};
+                      key = randomString(maxKeyLength - 1) + (space ? ' ' : '');
+                      await db.set(key, input);
+                    });
+                    it('get(key) -> record', async () => {
+                      const output = await db.get(key);
+                      // @ts-expect-error TS(2775): Assertions require every name in the call target t... Remove this comment to see the full error message
+                      assert.equal(JSON.stringify(output), JSON.stringify(input));
+                    });
+                    it('get(`${key} `) -> nullish', async () => {
+                      const output = await db.get(`${key} `);
+                      // @ts-expect-error TS(2775): Assertions require every name in the call target t... Remove this comment to see the full error message
+                      assert(output == null);
+                    });
+                    if (space) {
+                      it('get(key.slice(0, -1)) -> nullish', async () => {
+                        const output = await db.get(key.slice(0, -1));
+                        // @ts-expect-error TS(2775): Assertions require every name in the call target t... Remove this comment to see the full error message
+                        assert(output == null);
+                      });
+                    }
+                  });
+                }
+              });
+              it('get of unknown key -> nullish', async () => {
+                const key = randomString();
+                // @ts-expect-error TS(2775): Assertions require every name in the call target t... Remove this comment to see the full error message
+                assert((await db.get(key)) == null);
+              });
+              it('set+get works', async () => {
+                const input = {a: 1, b: new Randexp(/.+/).gen()};
+                const key = randomString();
+                await db.set(key, input);
+                const output = await db.get(key);
+                // @ts-expect-error TS(2775): Assertions require every name in the call target t... Remove this comment to see the full error message
+                assert.equal(JSON.stringify(output), JSON.stringify(input));
+              });
+              it('set+get with random key/value works', async () => {
+                const input = {testLongString: new Randexp(/[a-f0-9]{50000}/).gen()};
+                const key = randomString();
+                await db.set(key, input);
+                const output = await db.get(key);
+                // @ts-expect-error TS(2775): Assertions require every name in the call target t... Remove this comment to see the full error message
+                assert.equal(JSON.stringify(output), JSON.stringify(input));
+              });
+              it('findKeys works', async function (this: any) {
+                if (database === 'mongodb') { this.skip(); } // TODO: Fix mongodb.
+                // TODO setting a key with non ascii chars
+                const key = new Randexp(/([a-z]\w{0,20})foo\1/).gen();
+                await Promise.all([
+                  db.set(key, true),
+                  db.set(`${key}a`, true),
+                  db.set(`nonmatching_${key}`, false),
+                ]);
+                const keys = await db.findKeys(`${key}*`, null);
+                // @ts-expect-error TS(2775): Assertions require every name in the call target t... Remove this comment to see the full error message
+                assert.deepEqual(keys.sort(), [key, `${key}a`]);
+              });
+              it('findKeys with exclusion works', async function (this: any) {
+                if (database === 'mongodb') { this.skip(); } // TODO: Fix mongodb.
+                const key = new Randexp(/([a-z]\w{0,20})foo\1/).gen();
+                await Promise.all([
+                  db.set(key, true),
+                  db.set(`${key}a`, true),
+                  db.set(`${key}b`, false),
+                  db.set(`${key}b2`, false),
+                  db.set(`nonmatching_${key}`, false),
+                ]);
+                const keys = await db.findKeys(`${key}*`, `${key}b*`);
+                // @ts-expect-error TS(2775): Assertions require every name in the call target t... Remove this comment to see the full error message
+                assert.deepEqual(keys.sort(), [key, `${key}a`].sort());
+              });
+              it('findKeys with no matches works', async () => {
+                const key = new Randexp(/([a-z]\w{0,20})foo\1/).gen();
+                await db.set(key, true);
+                const keys = await db.findKeys(`${key}_nomatch_*`, null);
+                // @ts-expect-error TS(2775): Assertions require every name in the call target t... Remove this comment to see the full error message
+                assert.deepEqual(keys, []);
+              });
+              it('findKeys with no wildcard works', async () => {
+                const key = new Randexp(/([a-z]\w{0,20})foo\1/).gen();
+                await db.set(key, true);
+                const keys = await db.findKeys(key, null);
+                // @ts-expect-error TS(2775): Assertions require every name in the call target t... Remove this comment to see the full error message
+                assert.deepEqual(keys, [key]);
+              });
+              it('remove works', async () => {
+                const input = {a: 1, b: new Randexp(/.+/).gen()};
+                const key = randomString();
+                await db.set(key, input);
+                // @ts-expect-error TS(2775): Assertions require every name in the call target t... Remove this comment to see the full error message
+                assert.equal(JSON.stringify(await db.get(key)), JSON.stringify(input));
+                await db.remove(key);
+                // @ts-expect-error TS(2775): Assertions require every name in the call target t... Remove this comment to see the full error message
+                assert((await db.get(key)) == null);
+              });
+              it('getSub of existing property works', async () => {
+                await db.set('k', {sub1: {sub2: 'v'}});
+                // @ts-expect-error TS(2775): Assertions require every name in the call target t... Remove this comment to see the full error message
+                assert.equal(await db.getSub('k', ['sub1', 'sub2']), 'v');
+                // @ts-expect-error TS(2775): Assertions require every name in the call target t... Remove this comment to see the full error message
+                assert.deepEqual(await db.getSub('k', ['sub1']), {sub2: 'v'});
+                // @ts-expect-error TS(2775): Assertions require every name in the call target t... Remove this comment to see the full error message
+                assert.deepEqual(await db.getSub('k', []), {sub1: {sub2: 'v'}});
+              });
+              it('getSub of missing property returns nullish', async () => {
+                await db.set('k', {sub1: {}});
+                // @ts-expect-error TS(2775): Assertions require every name in the call target t... Remove this comment to see the full error message
+                assert((await db.getSub('k', ['sub1', 'sub2'])) == null);
+                await db.set('k', {});
+                // @ts-expect-error TS(2775): Assertions require every name in the call target t... Remove this comment to see the full error message
+                assert((await db.getSub('k', ['sub1', 'sub2'])) == null);
+                // @ts-expect-error TS(2775): Assertions require every name in the call target t... Remove this comment to see the full error message
+                assert((await db.getSub('k', ['sub1'])) == null);
+                await db.remove('k');
+                // @ts-expect-error TS(2775): Assertions require every name in the call target t... Remove this comment to see the full error message
+                assert((await db.getSub('k', ['sub1', 'sub2'])) == null);
+                // @ts-expect-error TS(2775): Assertions require every name in the call target t... Remove this comment to see the full error message
+                assert((await db.getSub('k', ['sub1'])) == null);
+                // @ts-expect-error TS(2775): Assertions require every name in the call target t... Remove this comment to see the full error message
+                assert((await db.getSub('k', [])) == null);
+              });
+              it('setSub can modify an existing property', async () => {
+                await db.set('k', {sub1: {sub2: 'v'}});
+                await db.setSub('k', ['sub1', 'sub2'], 'v2');
+                // @ts-expect-error TS(2775): Assertions require every name in the call target t... Remove this comment to see the full error message
+                assert.deepEqual(await db.get('k'), {sub1: {sub2: 'v2'}});
+                await db.setSub('k', ['sub1'], 'v2');
+                // @ts-expect-error TS(2775): Assertions require every name in the call target t... Remove this comment to see the full error message
+                assert.deepEqual(await db.get('k'), {sub1: 'v2'});
+                await db.setSub('k', [], 'v3');
+                // @ts-expect-error TS(2775): Assertions require every name in the call target t... Remove this comment to see the full error message
+                assert.equal(await db.get('k'), 'v3');
+              });
+              it('setSub can add a new property', async () => {
+                await db.remove('k');
+                await db.setSub('k', [], {});
+                // @ts-expect-error TS(2775): Assertions require every name in the call target t... Remove this comment to see the full error message
+                assert.deepEqual(await db.get('k'), {});
+                await db.setSub('k', ['sub1'], {});
+                // @ts-expect-error TS(2775): Assertions require every name in the call target t... Remove this comment to see the full error message
+                assert.deepEqual(await db.get('k'), {sub1: {}});
+                await db.setSub('k', ['sub1', 'sub2'], 'v');
+                // @ts-expect-error TS(2775): Assertions require every name in the call target t... Remove this comment to see the full error message
+                assert.deepEqual(await db.get('k'), {sub1: {sub2: 'v'}});
+                await db.remove('k');
+                await db.setSub('k', ['sub1', 'sub2'], 'v');
+                // @ts-expect-error TS(2775): Assertions require every name in the call target t... Remove this comment to see the full error message
+                assert.deepEqual(await db.get('k'), {sub1: {sub2: 'v'}});
+              });
+              it('setSub rejects attempts to set properties on primitives', async () => {
+                for (const v of ['hello world', 42, true]) {
+                  await db.set('k', v);
+                  assert.rejects(db.setSub('k', ['sub'], 'x'), {
+                    name: 'TypeError',
+                    message: /property "sub" on non-object/,
+                  });
+                  // @ts-expect-error TS(2775): Assertions require every name in the call target t... Remove this comment to see the full error message
+                  assert.deepEqual(await db.get('k'), v);
+                }
+              });
+              it('speed is acceptable', async function (this: any) {
+                this.timeout(180000);
+                const {speeds: {count = 1000, setMax = 3, getMax = 0.1, findKeysMax = 3, removeMax = 1} = {}} = dbSettings || {};
+                const input = {a: 1, b: new Randexp(/.+/).gen()};
+                // TODO setting a key with non ascii chars
+                const key = new Randexp(/([a-z]\w{0,20})foo\1/).gen();
+                // Pre-allocate an array before starting the timer so that time spent growing the
+                // array doesn't throw off the benchmarks.
+                const promises = [...Array(count + 1)].map(() => null);
+                const timers = {start: Date.now()};
+                for (let i = 0; i < count; ++i) { promises[i] = db.set(key + i, input); }
+                promises[count] = db.flush();
+                await Promise.all(promises);
+                // @ts-expect-error TS(2339): Property 'set' does not exist on type '{ start: nu... Remove this comment to see the full error message
+                timers.set = Date.now();
+                for (let i = 0; i < count; ++i) { promises[i] = db.get(key + i); }
+                await Promise.all(promises);
+                // @ts-expect-error TS(2339): Property 'get' does not exist on type '{ start: nu... Remove this comment to see the full error message
+                timers.get = Date.now();
+                for (let i = 0; i < count; ++i) { promises[i] = db.findKeys(key + i, null); }
+                await Promise.all(promises);
+                // @ts-expect-error TS(2339): Property 'findKeys' does not exist on type '{ star... Remove this comment to see the full error message
+                timers.findKeys = Date.now();
+                for (let i = 0; i < count; ++i) { promises[i] = db.remove(key + i); }
+                promises[count] = db.flush();
+                await Promise.all(promises);
+                // @ts-expect-error TS(2339): Property 'remove' does not exist on type '{ start:... Remove this comment to see the full error message
+                timers.remove = Date.now();
+                const timePerOp = {
+                  // @ts-expect-error TS(2339): Property 'set' does not exist on type '{ start: nu... Remove this comment to see the full error message
+                  set: (timers.set - timers.start) / count,
+                  // @ts-expect-error TS(2339): Property 'get' does not exist on type '{ start: nu... Remove this comment to see the full error message
+                  get: (timers.get - timers.set) / count,
+                  // @ts-expect-error TS(2339): Property 'findKeys' does not exist on type '{ star... Remove this comment to see the full error message
+                  findKeys: (timers.findKeys - timers.get) / count,
+                  // @ts-expect-error TS(2339): Property 'remove' does not exist on type '{ start:... Remove this comment to see the full error message
+                  remove: (timers.remove - timers.findKeys) / count,
+                };
+                speedTable.push([
+                  database,
+                  readCache ? 'yes' : 'no',
+                  writeBuffer ? 'yes' : 'no',
+                  count,
+                  timePerOp.set,
+                  timePerOp.get,
+                  timePerOp.findKeys,
+                  timePerOp.remove,
+                  // @ts-expect-error TS(2339): Property 'remove' does not exist on type '{ start:... Remove this comment to see the full error message
+                  timers.remove - timers.start,
+                  // @ts-expect-error TS(2339): Property 'remove' does not exist on type '{ start:... Remove this comment to see the full error message
+                  (timers.remove - timers.start) / count,
+                ]);
+                // Removes the "Acceptable ms/op" column if there is no enforced limit.
+                const filterColumn = (row: any) => {
+                  if (readCache && writeBuffer) { return row; }
+                  row.splice(1, 1);
+                  return row;
+                };
+                const acceptableTable = new Clitable({
+                  head: filterColumn(['op', 'Acceptable ms/op', 'Actual ms/op']),
+                  colWidths: filterColumn([10, 18, 18]),
+                });
+                acceptableTable.push(...[
+                  ['set', setMax, timePerOp.set],
+                  ['get', getMax, timePerOp.get],
+                  ['findKeys', findKeysMax, timePerOp.findKeys],
+                  ['remove', removeMax, timePerOp.remove],
+                ].map(filterColumn));
+                console.log(acceptableTable.toString());
+                if (readCache && writeBuffer) {
+                  // @ts-expect-error TS(2775): Assertions require every name in the call target t... Remove this comment to see the full error message
+                  assert(setMax >= timePerOp.set);
+                  // @ts-expect-error TS(2775): Assertions require every name in the call target t... Remove this comment to see the full error message
+                  assert(getMax >= timePerOp.get);
+                  // @ts-expect-error TS(2775): Assertions require every name in the call target t... Remove this comment to see the full error message
+                  assert(findKeysMax >= timePerOp.findKeys);
+                  // @ts-expect-error TS(2775): Assertions require every name in the call target t... Remove this comment to see the full error message
+                  assert(removeMax >= timePerOp.remove);
+                }
+              });
+            });
+          }
+        });
+      }
+    });
+  });
+});

package/test/test_bulk.ts

@@ -0,0 +1,69 @@
+import assert$0 from 'assert';
+import {Database} from '../index';
+import util from 'util';
+'use strict';
+const assert = assert$0.strict;
+const range = (N: any) => [...Array(N).keys()];
+describe(__filename, () => {
+  let db: any = null;
+  let mock: any = null;
+  const createDb = async (wrapperSettings: any) => {
+    const settings = {};
+    db = new Database('mock', settings, wrapperSettings);
+    // @ts-expect-error TS(2339): Property 'mock' does not exist on type '{}'.
+    mock = settings.mock;
+    mock.once('init', (cb: any) => cb());
+    await db.init();
+  };
+  afterEach(async () => {
+    if (mock != null) {
+      mock.removeAllListeners();
+      mock.once('close', (cb: any) => cb());
+      mock = null;
+    }
+    if (db != null) {
+      await db.close();
+      db = null;
+    }
+  });
+  describe('bulkLimit', () => {
+    const bulkLimits = [0, false, null, undefined, '', 1, 2];
+    for (const bulkLimit of bulkLimits) {
+      it(bulkLimit === undefined ? 'undefined' : JSON.stringify(bulkLimit), async () => {
+        await createDb({bulkLimit});
+        const gotWrites: any = [];
+        mock.on('set', util.callbackify(async (k: any, v: any) => gotWrites.push(1)));
+        mock.on('doBulk', util.callbackify(async (ops: any) => gotWrites.push(ops.length)));
+        const N = 10;
+        await Promise.all(range(N).map((i) => db.set(`key${i}`, `val${i}`)));
+        const wantLimit = bulkLimit || N;
+        // @ts-expect-error TS(2363): The right-hand side of an arithmetic operation mus... Remove this comment to see the full error message
+        const wantWrites = range(N / wantLimit).map((i) => wantLimit);
+        // @ts-expect-error TS(2775): Assertions require every name in the call target t... Remove this comment to see the full error message
+        assert.deepEqual(gotWrites, wantWrites);
+      });
+    }
+  });
+  it('bulk failures are retried individually', async () => {
+    await createDb({});
+    const gotDoBulkCalls: any = [];
+    mock.on('doBulk', util.callbackify(async (ops: any) => {
+      gotDoBulkCalls.push(ops.length);
+      throw new Error('test');
+    }));
+    const gotWrites = new Map();
+    const wantWrites = new Map();
+    mock.on('set', util.callbackify(async (k: any, v: any) => gotWrites.set(k, v)));
+    const N = 10;
+    await Promise.all(range(N).map(async (i) => {
+      const k = `key${i}`;
+      const v = `val${i}`;
+      wantWrites.set(k, JSON.stringify(v));
+      await db.set(k, v);
+    }));
+    // @ts-expect-error TS(2775): Assertions require every name in the call target t... Remove this comment to see the full error message
+    assert.deepEqual(gotDoBulkCalls, [N]);
+    // @ts-expect-error TS(2775): Assertions require every name in the call target t... Remove this comment to see the full error message
+    assert.deepEqual(gotWrites, wantWrites);
+  });
+});

package/test/{test_elasticsearch.js → test_elasticsearch.ts}

@@ -1,43 +1,40 @@
+import {deepEqual, rejects} from 'assert';
+import es from 'elasticsearch7';
+import {databases} from './lib/databases';
+import logging from '../lib/logging';
+import * as ueberdb from '../index';
 'use strict';
-
-const assert = require('assert').strict;
-const es = require('elasticsearch7');
-const {databases: {elasticsearch: cfg}} = require('./lib/databases');
-const logging = require('../lib/logging');
-const ueberdb = require('../index');
-
+const {databases: {elasticsearch: cfg}} = {databases};
 const logger = new class extends logging.ConsoleLogger {
-  info() {}
+  info() { }
   isInfoEnabled() { return false; }
 }();
 
-describe(__filename, function () {
+describe(__filename, function (this: any) {
   this.timeout(60000);
-
   const {base_index = 'ueberdb_test'} = cfg;
-  let client;
-  let db;
-
-  beforeEach(async function () {
+  let client: any;
+  let db: any;
+  beforeEach(async () => {
     client = new es.Client({
       node: `http://${cfg.host || '127.0.0.1'}:${cfg.port || '9200'}`,
     });
     await client.indices.delete({index: `${base_index}*`}, {ignore: [404]});
   });
-
-  afterEach(async function () {
-    if (db != null) await db.close();
+  afterEach(async () => {
+    if (db != null) { await db.close(); }
     db = null;
     await client.indices.delete({index: `${base_index}*`}, {ignore: [404]});
     client.close();
     client = null;
   });
-
-  describe('migration to schema v2', function () {
-    describe('no old data', function () {
+  describe('migration to schema v2', () => {
+    describe('no old data', () => {
       for (const migrate of [false, true]) {
-        it(`migration ${migrate ? 'en' : 'dis'}abled`, async function () {
-          const settings = {base_index, ...cfg};
+        it(`migration ${migrate ? 'en' : 'dis'}abled`, async () => {
+          // @ts-ignore
+          const settings = {base_index, migrate_to_newer_schema: undefined,
+            ...cfg};
           delete settings.migrate_to_newer_schema;
           db = new ueberdb.Database('elasticsearch', settings, {}, logger);
           await db.init();
@@ -45,14 +42,15 @@ describe(__filename, function () {
           const {body: res} = await client.indices.get({index: `${base_index}*`});
           for (const [k, v] of Object.entries(res)) {
             indices.push(k);
+            // @ts-expect-error TS(2571): Object is of type 'unknown'.
             indices.push(...Object.keys(v.aliases));
           }
-          assert.deepEqual(indices.sort(), [`${base_index}_s2`, `${base_index}_s2_i0`].sort());
+          deepEqual(indices.sort(), [`${base_index}_s2`, `${base_index}_s2_i0`].sort());
         });
       }
     });
-
-    describe('existing data', function () {
+    describe('existing data', () => {
+      // @ts-expect-error TS(2769): No overload matches this call.
       const data = new Map([
         ['foo:number', 42],
         ['foo:string', 'value'],
@@ -61,8 +59,7 @@ describe(__filename, function () {
         ['foo:p:s:string', 'value'],
         ['foo:p:s:object', {k: 'v'}],
       ]);
-
-      const setOld = async (k, v) => {
+      const setOld = async (k: any, v: any) => {
         const kp = k.split(':');
         const index = kp.length === 4 ? `${base_index}-${kp[0]}-${kp[2]}` : base_index;
         await client.index({
@@ -78,53 +75,51 @@ describe(__filename, function () {
         });
         await client.indices.refresh({index});
       };
-
-      beforeEach(async function () {
+      beforeEach(async () => {
         await Promise.all([...data].map(async ([k, v]) => await setOld(k, v)));
       });
-
-      it('migration disabled => init error', async function () {
-        const settings = {base_index, ...cfg};
+      it('migration disabled => init error', async () => {
+        // @ts-ignore
+        const settings = {base_index, migrate_to_newer_schema: undefined,
+          ...cfg};
         delete settings.migrate_to_newer_schema;
         db = new ueberdb.Database('elasticsearch', settings, {}, logger);
-        await assert.rejects(db.init(), /migrate_to_newer_schema/);
+        await rejects(db.init(), /migrate_to_newer_schema/);
       });
-
-      it('migration enabled', async function () {
+      it('migration enabled', async () => {
+        // @ts-ignore
         const settings = {base_index, ...cfg, migrate_to_newer_schema: true};
         db = new ueberdb.Database('elasticsearch', settings, {}, logger);
         await db.init();
         await Promise.all([...data].map(async ([k, v]) => {
-          assert.deepEqual(await db.get(k), v);
+          deepEqual(await db.get(k), v);
         }));
       });
-
-      it('each attempt uses a new index', async function () {
+      it('each attempt uses a new index', async () => {
         await setOld('a-x:b:c-x:d', 'v'); // Force a conversion failure.
-        const settings = {base_index, ...cfg, migrate_to_newer_schema: true};
+        cfg.base_index = base_index;
+        const settings = {...cfg, migrate_to_newer_schema: true};
         db = new ueberdb.Database('elasticsearch', settings, {}, logger);
-        const getIndices =
-            async () => Object.keys((await client.indices.get({index: `${base_index}_s2*`})).body);
-        assert.deepEqual(await getIndices(), []);
-        await assert.rejects(db.init(), /ambig/);
-        assert.deepEqual(await getIndices(), [`${base_index}_s2_migrate_attempt_0`]);
-        await assert.rejects(db.init(), /ambig/);
-        assert.deepEqual((await getIndices()).sort(), [
+        const getIndices = async () => Object.keys((await client.indices.get({index: `${base_index}_s2*`})).body);
+        deepEqual(await getIndices(), []);
+        await rejects(db.init(), /ambig/);
+        deepEqual(await getIndices(), [`${base_index}_s2_migrate_attempt_0`]);
+        await rejects(db.init(), /ambig/);
+        deepEqual((await getIndices()).sort(), [
           `${base_index}_s2_migrate_attempt_0`,
           `${base_index}_s2_migrate_attempt_1`,
         ]);
       });
-
-      it('final name not created until success', async function () {
+      it('final name not created until success', async () => {
       });
-
-      describe('ambiguous key', function () {
+      describe('ambiguous key', () => {
         for (const k of ['a:b:c-x:d', 'a-x:b:c:d', 'a-x:b:c-x:d']) {
-          it(k, async function () {
+          it(k, async () => {
             await setOld(k, 'v');
-            const settings = {base_index, ...cfg, migrate_to_newer_schema: true};
+            cfg.base_index = base_index;
+            const settings = {...cfg, migrate_to_newer_schema: true};
             db = new ueberdb.Database('elasticsearch', settings, {}, logger);
-            await assert.rejects(db.init(), /ambig/);
+            await rejects(db.init(), /ambig/);
           });
         }
       });