fix: revert "feat: remove nodeify* functions as obsolete (#52)" (#53)

This reverts commit b50a289.

Author: eglitise

README.md

@@ -102,6 +102,44 @@ console.log(newItems); // [2, 4];
 By default, `asyncmap` and `asyncfilter` run their operations in parallel; you
 can pass `false` as a third argument to make sure it happens serially.
 
+### Nodeify
+
+Export async functions (Promises) and import this with your ES5 code to use it
+with Node.
+
+```js
+var asyncbox = require('asyncbox')
+  , sleep = asyncbox.sleep
+  , nodeify = asyncbox.nodeify;
+
+nodeify(sleep(1000), function (err, timer) {
+  console.log(err); // null
+  console.log(timer); // timer obj
+});
+```
+
+### nodeifyAll
+
+If you have a whole library you want to export nodeified versions of, it's pretty easy:
+
+```js
+import { nodeifyAll } from 'asyncbox';
+
+async function foo () { ... }
+async function bar () { ... }
+let cb = nodeifyAll({foo, bar});
+export { foo, bar, cb };
+```
+
+Then in my ES5 script I can do:
+
+```js
+var myLib = require('mylib').cb;
+
+myLib.foo(function (err) { ... });
+myLib.bar(function (err) { ... });
+```
+
 ### waitForCondition
 
 Takes a condition (a function returning a boolean or boolean promise),

lib/asyncbox.ts

@@ -1,6 +1,9 @@
 import B from 'bluebird';
 import _ from 'lodash';
-import type {LongSleepOptions, WaitForConditionOptions} from './types.js';
+import type {
+  LongSleepOptions,
+  WaitForConditionOptions,
+} from './types.js';
 
 const LONG_SLEEP_THRESHOLD = 5000; // anything over 5000ms will turn into a spin
 
@@ -26,7 +29,11 @@ export async function sleep(ms: number): Promise<void> {
  */
 export async function longSleep(
   ms: number,
-  {thresholdMs = LONG_SLEEP_THRESHOLD, intervalMs = 1000, progressCb = null}: LongSleepOptions = {},
+  {
+    thresholdMs = LONG_SLEEP_THRESHOLD,
+    intervalMs = 1000,
+    progressCb = null,
+  }: LongSleepOptions = {},
 ): Promise<void> {
   if (ms < thresholdMs) {
     return await sleep(ms);
@@ -108,6 +115,35 @@ export async function retryInterval<T = any>(
 
 export const parallel = B.all;
 
+/**
+ * Export async functions (Promises) and import this with your ES5 code to use
+ * it with Node.
+ * @param promisey - A Promise or promise-like value to convert to a callback
+ * @param cb - The callback function to call with the result or error
+ */
+// eslint-disable-next-line promise/prefer-await-to-callbacks
+export function nodeify<R = any>(promisey: any, cb: (err: any, value?: R) => void): Promise<R> {
+  return B.resolve(promisey).nodeify(cb);
+}
+
+/**
+ * Node-ify an entire object of `Promise`-returning functions
+ * @param promiseyMap - An object containing functions that return Promises
+ */
+export function nodeifyAll<T extends Record<string, (...args: any[]) => any>>(
+  promiseyMap: T,
+): Record<string, (...args: any[]) => void> {
+  const cbMap: Record<string, (...args: any[]) => void> = {};
+  for (const [name, fn] of _.toPairs(promiseyMap)) {
+    cbMap[name] = function (...args: any[]) {
+      const _cb = args.slice(-1)[0] as (err: any, ...values: any[]) => void;
+      const fnArgs = args.slice(0, -1);
+      nodeify(fn(...fnArgs), _cb);
+    };
+  }
+  return cbMap;
+}
+
 /**
  * Fire and forget async function execution
  * @param fn - The function to execute asynchronously

test/asyncbox-specs.ts

@@ -5,6 +5,8 @@ import {
   longSleep,
   retry,
   retryInterval,
+  nodeify,
+  nodeifyAll,
   parallel,
   asyncmap,
   asyncfilter,
@@ -173,6 +175,60 @@ describe('retry', function () {
   });
 });
 
+describe('nodeifyAll', function () {
+  const asyncFn = async function (val: string): Promise<string> {
+    await sleep(15);
+    return val;
+  };
+  const asyncFn2 = async function (val: string): Promise<string[]> {
+    await sleep(15);
+    return [val, val + val];
+  };
+  const badAsyncFn = async function (): Promise<never> {
+    await sleep(15);
+    throw new Error('boo');
+  };
+  const cbMap = nodeifyAll({asyncFn, asyncFn2, badAsyncFn});
+  it('should turn async functions into nodey things', function (done) {
+    const start = Date.now();
+    nodeify(asyncFn('foo'), function (err: Error | null, val?: string, val2?: string) { // eslint-disable-line promise/prefer-await-to-callbacks
+      expect(err).to.not.exist;
+      expect(val2).to.not.exist;
+      expect(val!).to.equal('foo');
+      expect(Date.now() - start).to.be.at.least(14);
+      done();
+    });
+  });
+  it('should turn async functions into nodey things via nodeifyAll', function (done) {
+    const start = Date.now();
+    cbMap.asyncFn('foo', function (err: Error | null, val?: string, val2?: string) { // eslint-disable-line promise/prefer-await-to-callbacks
+      expect(err).to.not.exist;
+      expect(val2).to.not.exist;
+      expect(val!).to.equal('foo');
+      expect(Date.now() - start).to.be.at.least(14);
+      done();
+    });
+  });
+  it('should turn async functions into nodey things with mult params', function (done) {
+    const start = Date.now();
+    nodeify(asyncFn2('foo'), function (err: Error | null, val?: string[]) { // eslint-disable-line promise/prefer-await-to-callbacks
+      expect(err).to.not.exist;
+      expect(val!).to.eql(['foo', 'foofoo']);
+      expect(Date.now() - start).to.be.at.least(14);
+      done();
+    });
+  });
+  it('should handle errors correctly', function (done) {
+    const start = Date.now();
+    nodeify(badAsyncFn(), function (err: Error | null, val?: string) { // eslint-disable-line promise/prefer-await-to-callbacks
+      expect(val).to.not.exist;
+      expect(err!.message).to.equal('boo');
+      expect(Date.now() - start).to.be.at.least(14);
+      done();
+    });
+  });
+});
+
 describe('parallel', function () {
   const asyncFn = async function (val: number): Promise<number> {
     await sleep(50);