ueberdb2 4.0.11 → 4.0.15

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

@@ -1,46 +1,42 @@
+import assert$0 from 'assert';
+import {databases} from './lib/databases';
+import * as mysql from '../databases/mysql_db';
 'use strict';
-
-const assert = require('assert').strict;
-const {databases} = require('./lib/databases');
-const mysql = require('../databases/mysql_db');
-
-describe(__filename, function () {
-  beforeEach(async function () {
+const assert = assert$0.strict;
+describe(__filename, () => {
+  beforeEach(async function (this: any) {
     if (databases.mysql == null) return this.skip();
   });
-
-  it('connect error is detected during init()', async function () {
+  it('connect error is detected during init()', async () => {
     // Use an invalid TCP port to force a connection error.
     const db = new mysql.Database({...databases.mysql, port: 65536});
     // An error is expected; prevent it from being logged.
-    db.logger = Object.setPrototypeOf({error() {}}, db.logger);
+    db.logger = Object.setPrototypeOf({error() { }}, db.logger);
     await assert.rejects(db.init());
   });
-
-  it('query after fatal error works', async function () {
+  it('query after fatal error works', async () => {
     const db = new mysql.Database(databases.mysql);
     await db.init();
     // An error is expected; prevent it from being logged.
-    db.logger = Object.setPrototypeOf({error() {}}, db.logger);
+    db.logger = Object.setPrototypeOf({error() { }}, db.logger);
     // Sleep longer than the timeout to force a fatal error.
     await assert.rejects(db._query({sql: 'DO SLEEP(1);', timeout: 1}), {fatal: true});
     await assert.doesNotReject(db._query({sql: 'SELECT 1;'}));
     await db.close();
   });
-
-  it('query times out', async function () {
+  it('query times out', async () => {
     const db = new mysql.Database(databases.mysql);
     await db.init();
     // Timeout error messages are expected; prevent them from being logged.
-    db.logger = Object.setPrototypeOf({error() {}}, db.logger);
+    db.logger = Object.setPrototypeOf({error() { }}, db.logger);
     db.settings.queryTimeout = 100;
     await assert.doesNotReject(db._query({sql: 'DO SLEEP(0.090);'}));
     await assert.rejects(db._query({sql: 'DO SLEEP(0.110);'}));
     await db.close();
   });
-
-  it('queries run concurrently and are queued when pool is busy', async function () {
+  it('queries run concurrently and are queued when pool is busy', async () => {
     const connectionLimit = 10;
+    // @ts-expect-error TS(2339): Property 'Database' does not exist on type 'typeof... Remove this comment to see the full error message
     const db = new mysql.Database({...databases.mysql, connectionLimit});
     await db.init();
     // Set the query duration high enough to avoid flakiness on slow machines but low enough to keep
@@ -48,21 +44,19 @@ describe(__filename, function () {
     const queryDuration = 100;
     db.settings.queryTimeout = queryDuration + 100;
     const enqueueQuery = () => db._query({sql: `DO SLEEP(${queryDuration / 1000});`});
-
     // Reduce test flakiness by using slow queries to warm up the pool's connections.
     await Promise.all([...Array(connectionLimit)].map(enqueueQuery));
-
     // Time how long it takes to run just under 2 * connectionLimit queries.
     const nQueries = 2 * connectionLimit - 1;
     const start = Date.now();
     await Promise.all([...Array(nQueries)].map(enqueueQuery));
     const duration = Date.now() - start;
-
     const wantDurationLower = Math.ceil(nQueries / connectionLimit) * queryDuration;
+    // @ts-expect-error TS(2775): Assertions require every name in the call target t... Remove this comment to see the full error message
     assert(duration >= wantDurationLower, `took ${duration}ms, want >= ${wantDurationLower}ms`);
     const wantDurationUpper = wantDurationLower + queryDuration;
+    // @ts-expect-error TS(2775): Assertions require every name in the call target t... Remove this comment to see the full error message
     assert(duration < wantDurationUpper, `took ${duration}ms, want < ${wantDurationUpper}ms`);
-
     await db.close();
   });
 });

package/test/test_postgres.ts

@@ -0,0 +1,16 @@
+import {databases} from './lib/databases';
+import * as ueberdb from '../index';
+'use strict';
+import {equal} from 'assert';
+
+describe(__filename, () => {
+  it('connection string instead of settings object', async () => {
+    const {user, password, host, database} = databases.postgres;
+    console.log(`postgres://${user}:${password}@${host}/${database}`);
+    const db = new ueberdb.Database('postgres', `postgres://${user}:${password}@${host}/${database}`);
+    await db.init();
+    await db.set('key', 'val');
+    const val = await db.get('key') as string;
+    equal(val, 'val');
+  });
+});

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

@@ -1,22 +1,18 @@
+import assert$0 from 'assert';
+import * as ueberdb from '../index';
 'use strict';
-
-const assert = require('assert').strict;
-const ueberdb = require('../index');
-
-describe(__filename, function () {
-  let db;
-
-  beforeEach(async function () {
+const assert = assert$0.strict;
+describe(__filename, () => {
+  let db: any;
+  beforeEach(async () => {
     db = new ueberdb.Database('memory', {}, {});
     await db.init();
   });
-
-  afterEach(async function () {
+  afterEach(async () => {
     if (db != null) await db.close();
     db = null;
   });
-
-  it('setSub rejects __proto__', async function () {
+  it('setSub rejects __proto__', async () => {
     await db.set('k', {});
     await assert.rejects(db.setSub('k', ['__proto__'], 'v'));
   });

package/test/test_tojson.ts

@@ -0,0 +1,34 @@
+import assert$0 from 'assert';
+import * as ueberdb from '../index';
+'use strict';
+const assert = assert$0.strict;
+describe(__filename, () => {
+  let db: any = null;
+  before(async () => {
+    db = new ueberdb.Database('memory', {}, {});
+    await db.init();
+  });
+  after(async () => {
+    await db.close();
+  });
+  it('no .toJSON method', async () => {
+    await db.set('key', {prop: 'value'});
+    // @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('key'), {prop: 'value'});
+  });
+  it('direct', async () => {
+    await db.set('key', {toJSON: (arg: any) => `toJSON ${arg}`});
+    // @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('key'), 'toJSON ');
+  });
+  it('object property', async () => {
+    await db.set('key', {prop: {toJSON: (arg: any) => `toJSON ${arg}`}});
+    // @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('key'), {prop: 'toJSON prop'});
+  });
+  it('array entry', async () => {
+    await db.set('key', [{toJSON: (arg: any) => `toJSON ${arg}`}]);
+    // @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('key'), ['toJSON 0']);
+  });
+});

package/databases/mock_db.js

@@ -1,42 +0,0 @@
-'use strict';
-
-const events = require('events');
-
-exports.Database = class extends events.EventEmitter {
-  constructor(settings) {
-    super();
-    this.settings = {
-      writeInterval: 1,
-      ...settings,
-    };
-    settings.mock = this;
-  }
-
-  close(cb) {
-    this.emit('close', cb);
-  }
-
-  doBulk(ops, cb) {
-    this.emit('doBulk', ops, cb);
-  }
-
-  findKeys(key, notKey, cb) {
-    this.emit('findKeys', key, notKey, cb);
-  }
-
-  get(key, cb) {
-    this.emit('get', key, cb);
-  }
-
-  init(cb) {
-    this.emit('init', cb);
-  }
-
-  remove(key, cb) {
-    this.emit('remove', key, cb);
-  }
-
-  set(key, value, cb) {
-    this.emit('set', key, value, cb);
-  }
-};

package/databases/redis_db.js

@@ -1,96 +0,0 @@
-'use strict';
-
-/**
- * 2011 Peter 'Pita' Martischka
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS-IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-const AbstractDatabase = require('../lib/AbstractDatabase');
-const redis = require('redis');
-
-exports.Database = class extends AbstractDatabase {
-  constructor(settings) {
-    super();
-    this._client = null;
-    this.settings = settings || {};
-  }
-
-  get isAsync() { return true; }
-
-  async init() {
-    this._client = redis.createClient(this.settings);
-    await this._client.connect();
-    await this._client.ping();
-  }
-
-  async get(key) {
-    return await this._client.get(key);
-  }
-
-  async findKeys(key, notKey) {
-    const [type] = /^([^:*]+):\*$/.exec(key) || [];
-    if (type != null && ['*:*:*', `${key}:*`].includes(notKey)) {
-      // Performance optimization for a common Etherpad case.
-      return await this._client.sMembers(`ueberDB:keys:${type}`);
-    }
-    let keys = await this._client.keys(key.replace(/[?[\]\\]/g, '\\$&'));
-    if (notKey != null) {
-      const regex = this.createFindRegex(key, notKey);
-      keys = keys.filter((k) => regex.test(k));
-    }
-    return keys;
-  }
-
-  async set(key, value) {
-    const matches = /^([^:]+):([^:]+)$/.exec(key);
-    await Promise.all([
-      matches && this._client.sAdd(`ueberDB:keys:${matches[1]}`, matches[0]),
-      this._client.set(key, value),
-    ]);
-  }
-
-  async remove(key) {
-    const matches = /^([^:]+):([^:]+)$/.exec(key);
-    await Promise.all([
-      matches && this._client.sRem(`ueberDB:keys:${matches[1]}`, matches[0]),
-      this._client.del(key),
-    ]);
-  }
-
-  async doBulk(bulk) {
-    const multi = this._client.multi();
-
-    for (const {key, type, value} of bulk) {
-      const matches = /^([^:]+):([^:]+)$/.exec(key);
-      if (type === 'set') {
-        if (matches) {
-          multi.sAdd(`ueberDB:keys:${matches[1]}`, matches[0]);
-        }
-        multi.set(key, value);
-      } else if (type === 'remove') {
-        if (matches) {
-          multi.sRem(`ueberDB:keys:${matches[1]}`, matches[0]);
-        }
-        multi.del(key);
-      }
-    }
-
-    await multi.exec();
-  }
-
-  async close() {
-    await this._client.quit();
-    this._client = null;
-  }
-};

package/lib/AbstractDatabase.js

@@ -1,37 +0,0 @@
-'use strict';
-
-const logging = require('./logging');
-
-const nullLogger = logging.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) => s.replace(/[.+?^${}()|[\]\\]/g, '\\$&').replace(/\*/g, '.*');
-
-module.exports = class AbstractDatabase {
-  constructor() {
-    if (new.target === module.exports) {
-      throw new TypeError('cannot instantiate Abstract Database directly');
-    }
-    for (const fn of ['init', 'close', 'get', 'findKeys', 'remove', 'set']) {
-      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, notKey) {
-    let regex = `^(?=${simpleGlobToRegExp(key)}$)`;
-    if (notKey != null) regex += `(?!${simpleGlobToRegExp(notKey)}$)`;
-    return new RegExp(regex);
-  }
-
-  doBulk(operations, cb) {
-    throw new Error('the doBulk method must be implemented if write caching is enabled');
-  }
-
-  get isAsync() { return false; }
-};

package/test/test.js

@@ -1,328 +0,0 @@
-'use strict';
-
-const wtfnode = require('wtfnode'); // This should be first so that it can instrument everything.
-
-const Clitable = require('cli-table');
-const Randexp = require('randexp');
-const assert = require('assert').strict;
-const databases = require('./lib/databases').databases;
-const fs = require('fs').promises;
-const logging = require('../lib/logging');
-const ueberdb = require('../index');
-
-const maxKeyLength = 100;
-const randomString = (length = maxKeyLength) => new Randexp(new RegExp(`.{${length}}`)).gen();
-
-// eslint-disable-next-line mocha/no-top-level-hooks
-after(async function () {
-  // 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, function () {
-  let speedTable;
-  let db;
-
-  before(async function () {
-    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 function () {
-    console.log(speedTable.toString());
-  });
-
-  for (const database of Object.keys(databases)) {
-    const dbSettings = databases[database];
-    describe(database, function () {
-      for (const readCache of [false, true]) {
-        describe(`${readCache ? '' : 'no '}read cache`, function () {
-          for (const writeBuffer of [false, true]) {
-            describe(`${writeBuffer ? '' : 'no '}write buffer`, function () {
-              this.timeout(5000);
-
-              before(async function () {
-                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 function () {
-                await db.close();
-                if (dbSettings.filename) await fs.unlink(dbSettings.filename).catch(() => {});
-              });
-
-              describe('white space in key is not ignored', function () {
-                for (const space of [false, true]) {
-                  describe(`key ${space ? 'has' : 'does not have'} a trailing space`, function () {
-                    let input;
-                    let key;
-
-                    before(async function () {
-                      input = {a: 1, b: new Randexp(/.+/).gen()};
-                      key = randomString(maxKeyLength - 1) + (space ? ' ' : '');
-                      await db.set(key, input);
-                    });
-
-                    it('get(key) -> record', async function () {
-                      const output = await db.get(key);
-                      assert.equal(JSON.stringify(output), JSON.stringify(input));
-                    });
-
-                    it('get(`${key} `) -> nullish', async function () {
-                      const output = await db.get(`${key} `);
-                      assert(output == null);
-                    });
-
-                    if (space) {
-                      it('get(key.slice(0, -1)) -> nullish', async function () {
-                        const output = await db.get(key.slice(0, -1));
-                        assert(output == null);
-                      });
-                    }
-                  });
-                }
-              });
-
-              it('get of unknown key -> nullish', async function () {
-                const key = randomString();
-                assert(await db.get(key) == null);
-              });
-
-              it('set+get works', async function () {
-                const input = {a: 1, b: new Randexp(/.+/).gen()};
-                const key = randomString();
-                await db.set(key, input);
-                const output = await db.get(key);
-                assert.equal(JSON.stringify(output), JSON.stringify(input));
-              });
-
-              it('set+get with random key/value works', async function () {
-                const input = {testLongString: new Randexp(/[a-f0-9]{50000}/).gen()};
-                const key = randomString();
-                await db.set(key, input);
-                const output = await db.get(key);
-                assert.equal(JSON.stringify(output), JSON.stringify(input));
-              });
-
-              it('findKeys works', async function () {
-                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);
-                assert.deepEqual(keys.sort(), [key, `${key}a`]);
-              });
-
-              it('findKeys with exclusion works', async function () {
-                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*`);
-                assert.deepEqual(keys.sort(), [key, `${key}a`].sort());
-              });
-
-              it('findKeys with no matches works', async function () {
-                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);
-                assert.deepEqual(keys, []);
-              });
-
-              it('findKeys with no wildcard works', async function () {
-                const key = new Randexp(/([a-z]\w{0,20})foo\1/).gen();
-                await db.set(key, true);
-                const keys = await db.findKeys(key, null);
-                assert.deepEqual(keys, [key]);
-              });
-
-              it('remove works', async function () {
-                const input = {a: 1, b: new Randexp(/.+/).gen()};
-                const key = randomString();
-                await db.set(key, input);
-                assert.equal(JSON.stringify(await db.get(key)), JSON.stringify(input));
-                await db.remove(key);
-                assert(await db.get(key) == null);
-              });
-
-              it('getSub of existing property works', async function () {
-                await db.set('k', {sub1: {sub2: 'v'}});
-                assert.equal(await db.getSub('k', ['sub1', 'sub2']), 'v');
-                assert.deepEqual(await db.getSub('k', ['sub1']), {sub2: 'v'});
-                assert.deepEqual(await db.getSub('k', []), {sub1: {sub2: 'v'}});
-              });
-
-              it('getSub of missing property returns nullish', async function () {
-                await db.set('k', {sub1: {}});
-                assert(await db.getSub('k', ['sub1', 'sub2']) == null);
-
-                await db.set('k', {});
-                assert(await db.getSub('k', ['sub1', 'sub2']) == null);
-                assert(await db.getSub('k', ['sub1']) == null);
-
-                await db.remove('k');
-                assert(await db.getSub('k', ['sub1', 'sub2']) == null);
-                assert(await db.getSub('k', ['sub1']) == null);
-                assert(await db.getSub('k', []) == null);
-              });
-
-              it('setSub can modify an existing property', async function () {
-                await db.set('k', {sub1: {sub2: 'v'}});
-                await db.setSub('k', ['sub1', 'sub2'], 'v2');
-                assert.deepEqual(await db.get('k'), {sub1: {sub2: 'v2'}});
-
-                await db.setSub('k', ['sub1'], 'v2');
-                assert.deepEqual(await db.get('k'), {sub1: 'v2'});
-
-                await db.setSub('k', [], 'v3');
-                assert.equal(await db.get('k'), 'v3');
-              });
-
-              it('setSub can add a new property', async function () {
-                await db.remove('k');
-                await db.setSub('k', [], {});
-                assert.deepEqual(await db.get('k'), {});
-                await db.setSub('k', ['sub1'], {});
-                assert.deepEqual(await db.get('k'), {sub1: {}});
-                await db.setSub('k', ['sub1', 'sub2'], 'v');
-                assert.deepEqual(await db.get('k'), {sub1: {sub2: 'v'}});
-
-                await db.remove('k');
-                await db.setSub('k', ['sub1', 'sub2'], 'v');
-                assert.deepEqual(await db.get('k'), {sub1: {sub2: 'v'}});
-              });
-
-              it('setSub rejects attempts to set properties on primitives', async function () {
-                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/,
-                  });
-                  assert.deepEqual(await db.get('k'), v);
-                }
-              });
-
-              it('speed is acceptable', async function () {
-                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);
-                timers.set = Date.now();
-
-                for (let i = 0; i < count; ++i) promises[i] = db.get(key + i);
-                await Promise.all(promises);
-                timers.get = Date.now();
-
-                for (let i = 0; i < count; ++i) promises[i] = db.findKeys(key + i, null);
-                await Promise.all(promises);
-                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);
-                timers.remove = Date.now();
-
-                const timePerOp = {
-                  set: (timers.set - timers.start) / count,
-                  get: (timers.get - timers.set) / count,
-                  findKeys: (timers.findKeys - timers.get) / count,
-                  remove: (timers.remove - timers.findKeys) / count,
-                };
-                speedTable.push([
-                  database,
-                  readCache ? 'yes' : 'no',
-                  writeBuffer ? 'yes' : 'no',
-                  count,
-                  timePerOp.set,
-                  timePerOp.get,
-                  timePerOp.findKeys,
-                  timePerOp.remove,
-                  timers.remove - timers.start,
-                  (timers.remove - timers.start) / count,
-                ]);
-
-                // Removes the "Acceptable ms/op" column if there is no enforced limit.
-                const filterColumn = (row) => {
-                  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) {
-                  assert(setMax >= timePerOp.set);
-                  assert(getMax >= timePerOp.get);
-                  assert(findKeysMax >= timePerOp.findKeys);
-                  assert(removeMax >= timePerOp.remove);
-                }
-              });
-            });
-          }
-        });
-      }
-    });
-  }
-});
-
-// TODO: Need test which prefills with 1e7 of data then does a get.