ueberdb2 2.1.1 → 2.2.1

package/.github/workflows/npmpublish.yml

@@ -6,6 +6,7 @@ on:
     branches:
       - main
       - master
+      - v[0-9]+
 
 jobs:
   test:

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # Notable Changes
 
+## v2.2.0
+
+Compatibility changes:
+
+  * Passing callbacks to the database methods is deprecated; use the returned
+    Promises instead.
+
+New features:
+
+  * Database methods now return a Promise if a callback is not provided.
+
+Bug fixes:
+
+  * A call to `flush()` immediately after a call to `set()`, `setSub()`, or
+    `remove()` (within the same ECMAScript macro- or microtask) now flushes the
+    new write operation.
+  * Fixed a bug where `findKeys()` would return stale results when write
+    buffering is enabled and writes are pending.
+  * `couch`: Rewrote driver to fix numerous bugs.
+
 ## v2.1.1
 
 Security fix:

package/README.md

@@ -40,58 +40,48 @@ npm install ueberdb2
 ```javascript
 const ueberdb = require('ueberdb2');
 
-// mysql
-const db = new ueberdb.Database('mysql', {
-  user: 'root',
-  host: 'localhost',
-  password: '',
-  database: 'store',
-  engine: 'InnoDB',
-});
-
-// dirty to file system
-//const db = new ueberdb.Database('dirty', {filename: 'var/dirty.db'});
-
-async function example(db) {
-  await db.init();
-
-  // no need for await because it's already in cache.
-  db.set('valueA', {a: 1, b: 2});
-
-  db.get('valueA', function (err, value) {
-    // close the database connection.
-    db.close(function () {
-      process.exit(0);
-    });
+(async () => {
+  // mysql
+  const db = new ueberdb.Database('mysql', {
+    user: 'root',
+    host: 'localhost',
+    password: '',
+    database: 'store',
+    engine: 'InnoDB',
   });
-}
+  // dirty to file system
+  //const db = new ueberdb.Database('dirty', {filename: 'var/dirty.db'});
 
-example(db);
+  await db.init();
+  try {
+    await db.set('valueA', {a: 1, b: 2});
+    console.log('valueA is', await db.get('valueA'));
+  } finally {
+    await db.close();
+  }
+})();
 ```
 
 ### findKeys
 
 ```javascript
 const ueberdb = require('ueberdb2');
-const db = new ueberdb.Database('dirty', {filename: 'var/dirty.db'});
 
-async function example(db){
+(async () => {
+  const db = new ueberdb.Database('dirty', {filename: 'var/dirty.db'});
   await db.init();
-
-  // no need for await because it's already in cache.
-  db.set('valueA', {a: 1, b: 2});
-  db.set('valueA:h1', {a: 1, b: 2});
-  db.set('valueA:h2', {a: 3, b: 4});
-
-  db.findKeys('valueA:*', null, function (err, value) { // TODO: Check this
-    // value will be ['valueA:h1', 'valueA:h2']
-    db.close(function () {
-      process.exit(0);
-    });
-  });
-}
-
-example(db);
+  try {
+    await Promise.all([
+      db.set('valueA', {a: 1, b: 2}),
+      db.set('valueA:h1', {a: 1, b: 2}),
+      db.set('valueA:h2', {a: 3, b: 4}),
+    ]);
+    // prints [ 'valueA:h1', 'valueA:h2' ]
+    console.log(await db.findKeys('valueA:*', null));
+  } finally {
+    await db.close();
+  }
+})();
 ```
 
 ### Getting and setting subkeys
@@ -103,6 +93,7 @@ methods make this easier.
 #### `getSub`
 
 ```javascript
+const value = await db.getSub(key, propertyPath);
 db.getSub(key, propertyPath, callback);
 ```
 
@@ -115,40 +106,31 @@ exist or if the given property path does not exist.
 Examples:
 
 ```javascript
-db.set(key, {prop1: {prop2: ['value']}}, (err) => {
-  if (err != null) throw err;
+(async () => {
+  await db.set(key, {prop1: {prop2: ['value']}});
 
-  db.getSub(key, ['prop1', 'prop2', '0'], (err, val) => {
-    if (err != null) throw err;
-    console.log('1.', val); // prints "1. value"
-  });
+  const val1 = await db.getSub(key, ['prop1', 'prop2', '0']);
+  console.log('1.', val1); // prints "1. value"
 
-  db.getSub(key, ['prop1', 'prop2'], (err, val) => {
-    if (err != null) throw err;
-    console.log('2.', val); // prints "2. [ 'value' ]"
-  });
+  const val2 = await db.getSub(key, ['prop1', 'prop2']);
+  console.log('2.', val2); // prints "2. [ 'value' ]"
 
-  db.getSub(key, ['prop1'], (err, val) => {
-    if (err != null) throw err;
-    console.log('3.', val); // prints "3. { prop2: [ 'value' ] }"
-  });
+  const val3 = await db.getSub(key, ['prop1']);
+  console.log('3.', val3); // prints "3. { prop2: [ 'value' ] }"
 
-  db.getSub(key, [], (err, val) => {
-    if (err != null) throw err;
-    console.log('4.', val); // prints "4. { prop1: { prop2: [ 'value' ] } }"
-  });
+  const val4 = await db.getSub(key, []);
+  console.log('4.', val4); // prints "4. { prop1: { prop2: [ 'value' ] } }"
 
-  db.getSub(key, ['does', 'not', 'exist'], (err, val) => {
-    if (err != null) throw err;
-    console.log('5.', val); // prints "5. null" or "5. undefined"
-  });
+  const val5 = await db.getSub(key, ['does', 'not', 'exist']);
+  console.log('5.', val5); // prints "5. null" or "5. undefined"
 });
 ```
 
 #### `setSub`
 
 ```javascript
-db.setSub(key, propertyPath, value, cb);
+await db.setSub(key, propertyPath, value);
+db.setSub(key, propertyPath, value, callback);
 ```
 
 Fetches the object stored at `key`, walks the property path given in
@@ -156,30 +138,26 @@ Fetches the object stored at `key`, walks the property path given in
 must be an array. If `propertyPath` is an empty array then `setSub()` is
 equivalent to `set()`. Empty objects are created as needed if the property path
 does not exist (including if `key` does not exist in the database). It is an
-error to attempt to set a property on a non-object. `cb` is optional and is
-called when the database driver has reported that the change has been written.
+error to attempt to set a property on a non-object.
 
 Examples:
 
 ```javascript
-// Assumption: The database does not yet have any records.
+// Assumption: db does not yet have any records.
+(async () => {
+  // Equivalent to db.set('key1', 'value'):
+  await db.setSub('key1', [], 'value');
 
-// Equivalent to db.set('key1', 'value', cb):
-db.setSub('key1', [], 'value', cb);
+  // Equivalent to db.set('key2', {prop1: {prop2: {0: 'value'}}}):
+  await db.setSub('key2', ['prop1', 'prop2', '0'], 'value'):
 
-// Equivalent to db.set('key2', {prop1: {prop2: {0: 'value'}}}, cb):
-db.setSub('key2', ['prop1', 'prop2', '0'], 'value', cb):
+  await db.set('key3', {prop1: 'value'});
 
-db.set('key3', {prop1: 'value'}, (err) => {
-  if (err != null) return cb(err);
-  // Equivalent to db.set('key3', {prop1: 'value', prop2: 'other value'}, cb):
-  db.setSub('key3', ['prop2'], 'other value', cb);
-});
+  // Equivalent to db.set('key3', {prop1: 'value', prop2: 'other value'}):
+  await db.setSub('key3', ['prop2'], 'other value');
 
-db.set('key3', {prop1: 'value'}, (err) => {
-  if (err != null) return cb(err);
   // TypeError: Cannot set property "badProp" on non-object "value":
-  db.setSub('key3', ['prop1', 'badProp'], 'foo', cb);
+  await db.setSub('key3', ['prop1', 'badProp'], 'foo');
 });
 ```
 
@@ -196,13 +174,13 @@ const ueberdb = require('ueberdb2');
   const db = new ueberdb.Database(
       'dirty', {filename: 'var/dirty.db'}, {cache: 0});
   await db.init();
-  db.set('valueA', {a: 1, b: 2});
-  db.get('valueA', (err, value) => {
+  try {
+    await db.set('valueA', {a: 1, b: 2});
+    const value = await db.get('valueA');
     console.log(JSON.stringify(value));
-    db.close(() => {
-      process.exit(0);
-    });
-  });
+  } finally {
+    await db.close();
+  }
 })();
 ```
 
@@ -218,13 +196,13 @@ const ueberdb = require('ueberdb2');
   const db = new ueberdb.Database(
       'dirty', {filename: 'var/dirty.db'}, {writeInterval: 0});
   await db.init();
-  db.set('valueA', {a: 1, b: 2});
-  db.get('valueA', (err, value) => {
+  try {
+    await db.set('valueA', {a: 1, b: 2});
+    const value = await db.get('valueA');
     console.log(JSON.stringify(value));
-    db.close(() => {
-      process.exit(0);
-    });
-  });
+  } finally {
+    await db.close();
+  }
 })();
 ```
 

package/databases/couch_db.js

@@ -16,21 +16,14 @@
  */
 
 const AbstractDatabase = require('../lib/AbstractDatabase');
+const http = require('http');
 const nano = require('nano');
-const async = require('async');
-
-const DESIGN_NAME = 'ueberDb';
-const DESIGN_PATH = `_design/${DESIGN_NAME}`;
-
-const handleError = (er) => {
-  if (er) throw new Error(er);
-};
 
 exports.Database = class extends AbstractDatabase {
   constructor(settings) {
     super();
+    this.agent = null;
     this.db = null;
-    this.client = null;
     this.settings = settings;
 
     // force some settings
@@ -40,162 +33,110 @@ exports.Database = class extends AbstractDatabase {
     this.settings.json = false;
   }
 
-  init(callback) {
-    const settings = this.settings;
-    let client = null;
-    let db = null;
+  get isAsync() { return true; }
 
-    const config = {
-      url: `http://${settings.host}:${settings.port}`,
+  async init() {
+    this.agent = new http.Agent({
+      keepAlive: true,
+      maxSockets: this.settings.maxListeners || 1,
+    });
+    const client = nano({
+      url: `http://${this.settings.host}:${this.settings.port}`,
       requestDefaults: {
-        pool: {
-          maxSockets: settings.maxListeners || 1,
-        },
         auth: {
-          user: settings.user,
-          pass: settings.password,
+          username: this.settings.user,
+          password: this.settings.password,
         },
+        httpAgent: this.agent,
       },
-    };
-
-    const createDb = () => {
-      client.db.create(settings.database, (er, body) => {
-        if (er) return callback(er);
-        return setDb();
-      });
-    };
-
-    const setDb = () => {
-      db = client.use(settings.database);
-      checkUeberDbDesignDocument(db);
-      this.client = client;
-      this.db = db;
-      callback();
-    };
-
-    // Always ensure that couchDb has at least an empty design doc for UeberDb use
-    // this will be necessary for the `findKeys` method
-    const checkUeberDbDesignDocument = () => {
-      db.head(DESIGN_PATH, (er, _, header) => {
-        if (er && er.statusCode === 404) return db.insert({views: {}}, DESIGN_PATH, handleError);
-        if (er) throw new Error(er);
-      });
-    };
-
-    client = nano(config);
-    client.db.get(settings.database, (er, body) => {
-      if (er && er.statusCode === 404) return createDb();
-      if (er) return callback(er);
-      return setDb();
     });
+    try {
+      await client.db.get(this.settings.database);
+    } catch (err) {
+      if (err.statusCode !== 404) throw err;
+      await client.db.create(this.settings.database);
+    }
+    this.db = client.use(this.settings.database);
   }
 
-  get(key, callback) {
-    const db = this.db;
-    db.get(key, (er, doc) => {
-      if (er && er.statusCode !== 404) {
-        console.log('GET');
-        console.log(er);
-      }
-      if (doc == null) return callback(null, null);
-      callback(null, doc.value);
-    });
+  async get(key) {
+    let doc;
+    try {
+      doc = await this.db.get(key);
+    } catch (err) {
+      if (err.statusCode === 404) return null;
+      throw err;
+    }
+    return doc.value;
   }
 
-  findKeys(key, notKey, callback) {
-    const regex = this.createFindRegex(key, notKey);
-    const queryKey = `${key}__${notKey}`;
-    const db = this.db;
-
-    // always look up if the query haven't be done before
-    const checkQuery = () => {
-      db.get(DESIGN_PATH, (er, doc) => {
-        handleError(er);
-        const queryExists = queryKey in doc.views;
-        if (!queryExists) return createQuery(doc);
-        makeQuery();
-      });
-    };
-
-    // Cache the query for faster reuse in the future
-    const createQuery = (doc) => {
-      const mapFunction = {
-        map: `function (doc) { if (${regex}.test(doc._id)) { emit(doc._id, null); } }`,
-      };
-      doc.views[queryKey] = mapFunction;
-      db.insert(doc, DESIGN_PATH, (er) => {
-        handleError(er);
-        makeQuery();
-      });
-    };
-
-    // If this is the first time the request is used, this can take a while…
-    const makeQuery = (er) => {
-      db.view(DESIGN_NAME, queryKey, (er, docs) => {
-        handleError(er);
-        docs = docs.rows.map((doc) => doc.key);
-        callback(null, docs);
-      });
-    };
-
-    checkQuery();
+  async findKeys(key, notKey) {
+    const pfxLen = key.indexOf('*');
+    const pfx = pfxLen < 0 ? key : key.slice(0, pfxLen);
+    const results = await this.db.find({
+      selector: {
+        _id: pfxLen < 0 ? pfx : {
+          $gte: pfx,
+          // https://docs.couchdb.org/en/3.2.2/ddocs/views/collation.html#string-ranges
+          $lte: `${pfx}\ufff0`,
+          $regex: this.createFindRegex(key, notKey).source,
+        },
+      },
+      fields: ['_id'],
+    });
+    return results.docs.map((doc) => doc._id);
   }
 
-  set(key, value, callback) {
-    const db = this.db;
-    db.get(key, (er, doc) => {
-      if (doc == null) return db.insert({_id: key, value}, callback);
-      db.insert({_id: key, _rev: doc._rev, value}, callback);
+  async set(key, value) {
+    let doc;
+    try {
+      doc = await this.db.get(key);
+    } catch (err) {
+      if (err.statusCode !== 404) throw err;
+    }
+    await this.db.insert({
+      _id: key,
+      value,
+      ...doc == null ? {} : {
+        _rev: doc._rev,
+      },
     });
   }
 
-  remove(key, callback) {
-    const db = this.db;
-    db.head(key, (er, _, header) => {
-      if (er && er.statusCode === 404) return callback(null);
-      if (er) return callback(er);
-      // etag has additional quotation marks, remove them
-      const etag = JSON.parse(header).etag;
-      db.destroy(key, etag, (er, body) => {
-        if (er) return callback(er);
-        callback(null);
-      });
-    });
+  async remove(key) {
+    let header;
+    try {
+      header = await this.db.head(key);
+    } catch (err) {
+      if (err.statusCode === 404) return;
+      throw err;
+    }
+    // etag has additional quotation marks, remove them
+    const etag = JSON.parse(header.etag);
+    await this.db.destroy(key, etag);
   }
 
-  doBulk(bulk, callback) {
-    const db = this.db;
+  async doBulk(bulk) {
     const keys = bulk.map((op) => op.key);
     const revs = {};
+    for (const {key, value} of (await this.db.fetchRevs({keys})).rows) {
+      // couchDB will return error instead of value if key does not exist
+      if (value != null) revs[key] = value.rev;
+    }
     const setters = [];
-    async.series([
-      (callback) => {
-        db.fetchRevs({keys}, (er, r) => {
-          if (er) throw new Error(JSON.stringify(er));
-          const rows = r.rows;
-          for (const j in r.rows) {
-            // couchDB will return error instead of value if key does not exist
-            if (rows[j].value != null) revs[rows[j].key] = rows[j].value.rev;
-          }
-          callback();
-        });
-      },
-      (callback) => {
-        for (const item of bulk) {
-          const set = {_id: item.key};
-          if (revs[item.key] != null) set._rev = revs[item.key];
-          if (item.type === 'set') set.value = item.value;
-          if (item.type === 'remove') set._deleted = true;
-          setters.push(set);
-        }
-        callback();
-      },
-    ], (err) => {
-      db.bulk({docs: setters}, callback);
-    });
+    for (const item of bulk) {
+      const set = {_id: item.key};
+      if (revs[item.key] != null) set._rev = revs[item.key];
+      if (item.type === 'set') set.value = item.value;
+      if (item.type === 'remove') set._deleted = true;
+      setters.push(set);
+    }
+    await this.db.bulk({docs: setters});
   }
 
-  close(callback) {
-    if (callback) callback();
+  async close() {
+    this.db = null;
+    if (this.agent) this.agent.destroy();
+    this.agent = null;
   }
 };