chore(PouchDB-find): purified promise flow (#8860)

* refactor internal callback-flow to promises
* remove unused utils
* add JSDoc with usage example to `resolveToCallback`

Author: SourceR85

packages/node_modules/pouchdb-find/src/adapters/http/index.js

@@ -19,70 +19,50 @@ async function dbFetch(db, path, opts) {
   return json;
 }
 
-function createIndex(db, requestDef, callback) {
-  dbFetch(db, '_index', {
+async function createIndex(db, requestDef) {
+  return await dbFetch(db, '_index', {
     method: 'POST',
     body: massageCreateIndexRequest(requestDef)
-  })
-    .then((result) => {
-      callback(null, result);
-    })
-    .catch(callback);
+  });
 }
 
-function find(db, requestDef, callback) {
+async function find(db, requestDef) {
   validateSelector(requestDef.selector, true);
-  dbFetch(db, '_find', {
+  return await dbFetch(db, '_find', {
     method: 'POST',
     body: requestDef
-  })
-    .then((result) => {
-      callback(null, result);
-    })
-    .catch(callback);
+  });
 }
 
-function explain(db, requestDef, callback) {
-  dbFetch(db, '_explain', {
+async function explain(db, requestDef) {
+  return await dbFetch(db, '_explain', {
     method: 'POST',
     body: requestDef
-  })
-    .then((result) => {
-      callback(null, result);
-    })
-    .catch(callback);
+  });
 }
 
-function getIndexes(db, callback) {
-  return dbFetch(db, '_index', {
-    method: 'GET',
-  })
-    .then((result) => {
-      callback(null, result);
-    })
-    .catch(callback);
+async function getIndexes(db) {
+  return await dbFetch(db, '_index', {
+    method: 'GET'
+  });
 }
 
-function deleteIndex(db, indexDef, callback) {
+async function deleteIndex(db, indexDef) {
   const ddoc = indexDef.ddoc;
   const type = indexDef.type || 'json';
   const name = indexDef.name;
 
   if (!ddoc) {
-    return callback(new Error('you must provide an index\'s ddoc'));
+    throw new Error('you must provide an index\'s ddoc');
   }
 
   if (!name) {
-    return callback(new Error('you must provide an index\'s name'));
+    throw new Error('you must provide an index\'s name');
   }
 
   const url = '_index/' + [ddoc, type, name].map(encodeURIComponent).join('/');
 
-  dbFetch(db, url, { method: 'DELETE' })
-    .then((result) => {
-      callback(null, result);
-    })
-    .catch(callback);
+  return await dbFetch(db, url, { method: 'DELETE' });
 }
 
 export {

packages/node_modules/pouchdb-find/src/adapters/local/index.js

@@ -1,19 +1,12 @@
-import { callbackify } from '../../utils';
 import createIndex from './create-index';
-import {find,  explain } from './find';
+import { find, explain } from './find';
 import getIndexes from './get-indexes';
 import deleteIndex from './delete-index';
 
-const createIndexAsCallback = callbackify(createIndex);
-const findAsCallback = callbackify(find);
-const explainAsCallback = callbackify(explain);
-const getIndexesAsCallback = callbackify(getIndexes);
-const deleteIndexAsCallback = callbackify(deleteIndex);
-
 export {
-  createIndexAsCallback as createIndex,
-  findAsCallback as find,
-  getIndexesAsCallback as getIndexes,
-  deleteIndexAsCallback as deleteIndex,
-  explainAsCallback as explain
+  createIndex,
+  find,
+  getIndexes,
+  deleteIndex,
+  explain
 };

packages/node_modules/pouchdb-find/src/index.js

@@ -1,64 +1,50 @@
-import { toPromise, isRemote } from 'pouchdb-utils';
+import { isRemote } from 'pouchdb-utils';
+import { resolveToCallback } from './utils';
 import * as http from './adapters/http/index';
 import * as local from './adapters/local/index';
 
 const plugin = {};
-plugin.createIndex = toPromise(function (requestDef, callback) {
-
+plugin.createIndex = resolveToCallback(async function (requestDef) {
   if (typeof requestDef !== 'object') {
-    return callback(new Error('you must provide an index to create'));
+    throw new Error('you must provide an index to create');
   }
 
   const createIndex = isRemote(this) ?
     http.createIndex : local.createIndex;
-  createIndex(this, requestDef, callback);
+  return createIndex(this, requestDef);
 });
 
-plugin.find = toPromise(function (requestDef, callback) {
-
-  if (typeof callback === 'undefined') {
-    callback = requestDef;
-    requestDef = undefined;
-  }
-
+plugin.find = resolveToCallback(async function (requestDef) {
   if (typeof requestDef !== 'object') {
-    return callback(new Error('you must provide search parameters to find()'));
+    throw new Error('you must provide search parameters to find()');
   }
 
   const find = isRemote(this) ? http.find : local.find;
-  find(this, requestDef, callback);
+  return find(this, requestDef);
 });
 
-plugin.explain = toPromise(function (requestDef, callback) {
-
-  if (typeof callback === 'undefined') {
-    callback = requestDef;
-    requestDef = undefined;
-  }
-
+plugin.explain = resolveToCallback(async function (requestDef) {
   if (typeof requestDef !== 'object') {
-    return callback(new Error('you must provide search parameters to explain()'));
+    throw new Error('you must provide search parameters to explain()');
   }
 
   const find = isRemote(this) ? http.explain : local.explain;
-  find(this, requestDef, callback);
+  return find(this, requestDef);
 });
 
-plugin.getIndexes = toPromise(function (callback) {
-
+plugin.getIndexes = resolveToCallback(async function () {
   const getIndexes = isRemote(this) ? http.getIndexes : local.getIndexes;
-  getIndexes(this, callback);
+  return getIndexes(this);
 });
 
-plugin.deleteIndex = toPromise(function (indexDef, callback) {
-
+plugin.deleteIndex = resolveToCallback(async function (indexDef) {
   if (typeof indexDef !== 'object') {
-    return callback(new Error('you must provide an index to delete'));
+    throw new Error('you must provide an index to delete');
   }
 
   const deleteIndex = isRemote(this) ?
     http.deleteIndex : local.deleteIndex;
-  deleteIndex(this, indexDef, callback);
+  return deleteIndex(this, indexDef);
 });
 
 export default plugin;

packages/node_modules/pouchdb-find/src/utils.js

@@ -4,88 +4,6 @@ import {
   parseField
 } from 'pouchdb-selector-core';
 
-import { nextTick } from 'pouchdb-utils';
-
-function once(fun) {
-  let called = false;
-  return function (...args) {
-    if (called) {
-      console.trace();
-      throw new Error('once called  more than once');
-    } else {
-      called = true;
-      fun.apply(this, args);
-    }
-  };
-}
-function toPromise(func) {
-  //create the function we will be returning
-  return function (...args) {
-    const self = this;
-    const tempCB = (typeof args[args.length - 1] === 'function') ? args.pop() : false;
-    // if the last argument is a function, assume its a callback
-    let usedCB;
-    if (tempCB) {
-      // if it was a callback, create a new callback which calls it,
-      // but do so async so we don't trap any errors
-      usedCB = function (err, resp) {
-        nextTick(function () {
-          tempCB(err, resp);
-        });
-      };
-    }
-    const promise = new Promise(function (fulfill, reject) {
-      try {
-        const callback = once(function (err, mesg) {
-          if (err) {
-            reject(err);
-          } else {
-            fulfill(mesg);
-          }
-        });
-        // create a callback for this invocation
-        // apply the function in the orig context
-        args.push(callback);
-        func.apply(self, args);
-      } catch (e) {
-        reject(e);
-      }
-    });
-    // if there is a callback, call it back
-    if (usedCB) {
-      promise.then(function (result) {
-        usedCB(null, result);
-      }, usedCB);
-    }
-    promise.cancel = function () {
-      return this;
-    };
-    return promise;
-  };
-}
-
-function callbackify(fun) {
-  return function (...args) {
-    const cb = args.pop();
-    const promise = fun.apply(this, args);
-    promisedCallback(promise, cb);
-    return promise;
-  };
-}
-
-function promisedCallback(promise, callback) {
-  promise.then(function (res) {
-    nextTick(function () {
-      callback(null, res);
-    });
-  }, function (reason) {
-    nextTick(function () {
-      callback(reason);
-    });
-  });
-  return promise;
-}
-
 const nativeFlat = (...args) => args.flat(Infinity);
 
 const polyFlat = (...args) => {
@@ -200,19 +118,43 @@ function uniq(arr) {
   return Array.from(new Set(arr));
 }
 
+/**
+ * Callbackifyable wrapper for async functions
+ *
+ * @template T, Args
+ * @param {(...args: Args) => Promise<T>} fun
+ * @returns {<CBArgs = [...Args, (err: any, value: T) => void], InnerArgs extends Args | CBArgs>(...innerArgs: InnerArgs) => InnerArgs extends CBArgs ? void : Promise<T>}
+ *
+ * @example
+ * const fn = resolveToCallback(async () => { return 42; })
+ * // with callback:
+ * fn((err, value) => { ... })
+ * // with await:
+ * const value = await fn()
+ */
+function resolveToCallback(fun) {
+  return function (...args) {
+    const maybeCallback = args[args.length - 1];
+    if (typeof maybeCallback === "function") {
+      const fulfilled = maybeCallback.bind(null, null);
+      const rejected = maybeCallback.bind(null);
+      fun.apply(this, args.slice(0, -1)).then(fulfilled, rejected);
+    } else {
+      return fun.apply(this, args);
+    }
+  };
+}
+
 export {
   arrayEquals,
   arrayToObject,
-  callbackify,
   flatten,
   max,
   mergeObjects,
-  once,
   oneArrayIsStrictSubArrayOfOther,
   oneArrayIsSubArrayOfOther,
   oneSetIsSubArrayOfOther,
   pick,
-  promisedCallback,
-  toPromise,
+  resolveToCallback,
   uniq
 };