aveazul 0.1.3 → 0.1.5

package/README.md

@@ -2,6 +2,10 @@
 
 AveAzul ("Blue Bird" in Spanish) is a Promise library that extends native Promises with Bluebird-like utility methods. Built on top of native Promises, it provides a familiar API for Node.js developers who are used to working with [Bluebird](https://github.com/petkaantonov/bluebird) ([npm](https://www.npmjs.com/package/bluebird)).
 
+This library helps migrate legacy code that uses Bluebird specific APIs to native Promises with minimal changes. It aims to provide a drop-in replacement that maintains compatibility while leveraging native Promises.
+
+Do you prefer Bluebird's API with native Promises? AveAzul gives you both - familiar Bluebird methods built on native Promise.
+
 ## Installation
 
 ```bash
@@ -11,29 +15,60 @@ npm install aveazul
 ## Usage
 
 ```javascript
-const AveAzul = require('aveazul');
+const AveAzul = require("aveazul");
 
 // Basic Promise usage
 const promise = new AveAzul((resolve) => resolve(42));
-promise.then(value => console.log(value)); // 42
+promise.then((value) => console.log(value)); // 42
 
 // Utility methods
 AveAzul.resolve([1, 2, 3])
-  .map(x => x * 2)
-  .filter(x => x > 2)
-  .then(result => console.log(result)); // [4, 6]
+  .map((x) => x * 2)
+  .filter((x) => x > 2)
+  .then((result) => console.log(result)); // [4, 6]
 
 // Promisify callback-style functions
-const fs = require('fs');
+const fs = require("fs");
 const readFile = AveAzul.promisify(fs.readFile);
-readFile('file.txt').then(content => console.log(content));
+readFile("file.txt").then((content) => console.log(content));
+// Properties from the original function are preserved
+console.log(readFile.length); // Original function's length property
 
 // Promisify all methods of an object
 const obj = {
-  method(cb) { cb(null, 'result'); }
+  method(cb) {
+    cb(null, "result");
+  },
 };
 AveAzul.promisifyAll(obj);
-obj.methodAsync().then(result => console.log(result)); // 'result'
+obj.methodAsync().then((result) => console.log(result)); // 'result'
+
+// Resource management with disposer and using
+const getResource = () => {
+  return AveAzul.resolve({
+    data: "important data",
+    close: () => console.log("Resource closed!"),
+  }).disposer((resource) => resource.close());
+};
+
+AveAzul.using(getResource(), (resource) => {
+  console.log(resource.data); // "important data"
+  return AveAzul.resolve("operation completed");
+}).then((result) => {
+  console.log(result); // "operation completed"
+  // Resource is automatically closed here, even if an error occurred
+});
+
+// Using spread to apply array results as arguments
+AveAzul.all([getUser(1), getPosts(1), getComments(1)]).spread(
+  (user, posts, comments) => {
+    // Instead of using .then(([user, posts, comments]) => {...})
+    console.log(
+      `User ${user.name} has ${posts.length} posts and ${comments.length} comments`
+    );
+    return { user, activity: { posts, comments } };
+  }
+);
 ```
 
 ## API
@@ -47,15 +82,15 @@ obj.methodAsync().then(result => console.log(result)); // 'result'
 - `each(fn)` - Iterate over array elements
 - `delay(ms)` - Delay resolution
 - `timeout(ms, message?)` - Reject after specified time
-- `try(fn)` - Wrap sync/async functions
 - `props(obj)` - Resolve object properties
-- `catchIf(predicate, fn)` - Catch specific errors
+- `spread(fn)` - Apply array values as arguments to function
 - `tapCatch(fn)` - Execute side effects on rejection
 - `reduce(fn, initialValue?)` - Reduce array elements
 - `throw(reason)` - Return rejected promise
 - `catchThrow(reason)` - Catch and throw new error
 - `catchReturn(value)` - Catch and return value
 - `get(propertyPath)` - Retrieve property value
+- `disposer(fn)` - Create a disposer for use with AveAzul.using() for resource cleanup
 
 ### Static Methods
 
@@ -64,11 +99,16 @@ obj.methodAsync().then(result => console.log(result)); // 'result'
 - `try(fn)` - Wrap sync/async functions
 - `props(obj)` - Resolve object properties
 - `defer()` - Create a deferred promise
-- `promisify(fn, options?)` - Convert callback-style functions to promises
+- `promisify(fn, options?)` - Convert callback-style functions to promises (preserves original function properties)
+- `fromNode(fn, options?)` - Convert Node-style callback functions to promise-returning functions
+- `fromCallback(fn, options?)` - Alias for fromNode
 - `each(items, fn)` - Iterate over array elements
 - `reduce(array, fn, initialValue?)` - Reduce array elements
+- `method(fn)` - Creates a method that returns a promise resolving to the value returned by the original function
 - `throw(reason)` - Return rejected promise
 - `promisifyAll(target, options?)` - Convert all methods of an object/class to promises
+- `using(resources, fn)` - Manage resources with automatic cleanup
+- `join(...values, handler?)` - Wait for multiple promises and pass their resolved values as separate arguments to the handler function. If no handler is provided, behaves like Promise.all
 
 ### PromisifyAll Options
 
@@ -76,8 +116,6 @@ obj.methodAsync().then(result => console.log(result)); // 'result'
 - `filter` - Filter function to determine which methods to promisify
 - `promisifier` - Custom function to handle promisification
 - `multiArgs` (default: false) - Whether to support multiple callback arguments
-- `excludeMain` (default: false) - Whether to exclude promisifying the main object/class
-- `context` - The context (this) to use when calling methods
 
 ## Development
 

package/lib/aveazul.js

@@ -1,7 +1,11 @@
 "use strict";
 
 const xaa = require("xaa");
-const { promisify: nodePromisify } = require("node:util");
+const { promisify } = require("./promisify");
+const { promisifyAll } = require("./promisify-all");
+const { Disposer } = require("./disposer");
+const { using } = require("./using");
+const { isPromise, triggerUncaughtException } = require("./util");
 
 /**
  * AveAzul ("Blue Bird" in Spanish) - Extended Promise class that provides Bluebird-like utility methods
@@ -28,8 +32,8 @@ class AveAzul extends Promise {
    * @returns {Promise} Promise that resolves with the original value
    */
   tap(fn) {
-    return this.then(value => {
-      fn(value);
+    return this.then(async (value) => {
+      await fn(value);
       return value;
     });
   }
@@ -41,7 +45,7 @@ class AveAzul extends Promise {
    * @returns {Promise} Promise that resolves with the filtered array
    */
   filter(fn) {
-    return this.then(value => xaa.filter(value, fn));
+    return this.then((value) => xaa.filter(value, fn));
   }
 
   /**
@@ -51,7 +55,7 @@ class AveAzul extends Promise {
    * @returns {Promise} Promise that resolves with the mapped array
    */
   map(fn) {
-    return this.then(value => xaa.map(value, fn));
+    return this.then((value) => xaa.map(value, fn));
   }
 
   /**
@@ -71,7 +75,18 @@ class AveAzul extends Promise {
    * @returns {Promise} Promise that resolves when iteration is complete
    */
   each(fn) {
-    return this.then(value => xaa.each(value, fn));
+    return this.then(async (value) => {
+      const result = [];
+      for (let i = 0; i < value.length; i++) {
+        let x = value[i];
+        if (isPromise(x)) {
+          x = await x;
+        }
+        await fn(x, i, value.length);
+        result.push(x);
+      }
+      return result;
+    });
   }
 
   /**
@@ -80,7 +95,7 @@ class AveAzul extends Promise {
    * @returns {Promise} Promise that resolves after the delay
    */
   delay(ms) {
-    return this.then(value => xaa.delay(ms, value));
+    return xaa.delay(ms);
   }
 
   /**
@@ -89,43 +104,8 @@ class AveAzul extends Promise {
    * @param {string} [message] - Optional error message
    * @returns {Promise} Promise that rejects if timeout occurs
    */
-  timeout(ms, message = "Operation timed out") {
-    return new AveAzul((resolve, reject) => {
-      const timer = setTimeout(() => {
-        reject(new Error(message));
-      }, ms);
-
-      this.then(
-        value => {
-          clearTimeout(timer);
-          resolve(value);
-        },
-        err => {
-          clearTimeout(timer);
-          reject(err);
-        }
-      );
-    });
-  }
-
-  /**
-   * Bluebird-style try() for wrapping sync/async functions
-   * @param {Function} fn - Function to execute
-   * @returns {Promise} Promise that resolves with the function's return value
-   */
-  try(fn) {
-    return new AveAzul((resolve, reject) => {
-      try {
-        const result = fn();
-        if (result && typeof result.then === "function") {
-          result.then(resolve, reject);
-        } else {
-          resolve(result);
-        }
-      } catch (err) {
-        reject(err);
-      }
-    });
+  timeout(ms, message = "operation timed out") {
+    return AveAzul.resolve(xaa.timeout(ms, message).run(this));
   }
 
   /**
@@ -133,34 +113,18 @@ class AveAzul extends Promise {
    * @param {Object} obj - Object with promise values
    * @returns {Promise} Promise that resolves with an object of resolved values
    */
-  props(obj) {
-    const keys = Object.keys(obj);
-    const values = keys.map(k => obj[k]);
-
-    return AveAzul.all(values).then(results => {
-      const resolved = {};
-      keys.forEach((k, i) => {
-        resolved[k] = results[i];
+  props() {
+    return this.then((value) => {
+      const keys = Object.keys(value);
+      const values = keys.map((k) => value[k]);
+
+      return AveAzul.all(values).then((results) => {
+        const resolved = {};
+        keys.forEach((k, i) => {
+          resolved[k] = results[i];
+        });
+        return resolved;
       });
-      return resolved;
-    });
-  }
-
-  /**
-   * Bluebird-style catchIf() with predicate matching
-   * @param {Function|Error} predicate - Error class or predicate function
-   * @param {Function} fn - Handler function
-   * @returns {Promise} Promise with conditional catch handler
-   */
-  catchIf(predicate, fn) {
-    return this.catch(err => {
-      if (
-        (typeof predicate === "function" && !predicate.prototype && predicate(err)) ||
-        (typeof predicate === "function" && predicate.prototype && err instanceof predicate)
-      ) {
-        return fn(err);
-      }
-      throw err;
     });
   }
 
@@ -170,7 +134,7 @@ class AveAzul extends Promise {
    * @returns {Promise} Promise that maintains the rejection
    */
   tapCatch(fn) {
-    return this.catch(err => {
+    return this.catch((err) => {
       fn(err);
       throw err;
     });
@@ -184,7 +148,32 @@ class AveAzul extends Promise {
    * @returns {Promise} Promise that resolves with the final reduced value
    */
   reduce(fn, initialValue) {
-    return this.then(array => AveAzul.reduce(array, fn, initialValue));
+    const hasInitial = arguments.length > 1;
+
+    return this.then(async (array) => {
+      const len = array.length;
+      let value;
+      let idx;
+      if (hasInitial) {
+        idx = 0;
+        value = initialValue;
+      } else {
+        idx = 1;
+        value = array[0];
+      }
+
+      value = isPromise(value) ? await value : value;
+
+      for (; idx < len; idx++) {
+        let x = array[idx];
+        if (isPromise(x)) {
+          x = await x;
+        }
+        value = await fn(value, x, idx, len);
+      }
+
+      return value;
+    });
   }
 
   /**
@@ -202,7 +191,9 @@ class AveAzul extends Promise {
    * @returns {Promise} Promise that rejects with the new reason
    */
   catchThrow(reason) {
-    return this.catch(() => AveAzul.throw(reason));
+    return this.catch(() => {
+      throw reason;
+    });
   }
 
   /**
@@ -216,26 +207,50 @@ class AveAzul extends Promise {
 
   /**
    * Bluebird-style get() for retrieving a property value
-   * @param {string|number} propertyPath - Path to the property (can be nested using dot notation)
+   * @param {string|number} key - Key to retrieve
    * @returns {Promise} Promise that resolves with the property value
    */
-  get(propertyPath) {
-    return this.then(value => {
-      if (value == null) {
-        throw new TypeError("Cannot read property '" + propertyPath + "' of " + value);
-      }
+  get(key) {
+    return this.then((value) => value[key]);
+  }
 
-      let result = value;
-      const props = String(propertyPath).split(".");
+  /**
+   * Bluebird-style disposer() for resource cleanup
+   * @param {Function} fn - Cleanup function
+   * @returns {Disposer} Disposer object
+   */
+  disposer(fn) {
+    if (typeof fn !== "function") {
+      throw new TypeError("Expected a function");
+    }
+
+    return new Disposer(fn, this);
+  }
+
+  /**
+   * Bluebird-style spread() method for handling array arguments
+   * Similar to Bluebird's Promise.prototype.spread()
+   * @param {Function} fn - Function to apply to the array arguments
+   * @returns {Promise} Promise that resolves with the function's return value
+   */
+  spread(fn) {
+    if (typeof fn !== "function") {
+      return AveAzul.reject(
+        new TypeError("expecting a function but got " + fn)
+      );
+    }
 
-      for (const prop of props) {
-        if (result == null) {
-          throw new TypeError("Cannot read property '" + prop + "' of " + result);
+    return this.then(async (args) => {
+      if (Array.isArray(args)) {
+        for (let i = 0; i < args.length; i++) {
+          if (isPromise(args[i])) {
+            args[i] = await args[i];
+          }
         }
-        result = result[prop];
+        return fn(...args);
+      } else {
+        return fn(args);
       }
-
-      return result;
     });
   }
 }
@@ -270,18 +285,18 @@ AveAzul.map = (value, fn) => AveAzul.resolve(xaa.map(value, fn));
  * @param {Function} fn - Function to execute
  * @returns {Promise} Promise that resolves with the function's return value
  */
-AveAzul.try = fn => AveAzul.resolve(xaa.wrap(fn));
+AveAzul.try = (fn) => AveAzul.resolve(xaa.wrap(fn));
 
 /**
  * Bluebird-style props() for object properties
  * @param {Object} obj - Object with promise values
  * @returns {Promise} Promise that resolves with an object of resolved values
  */
-AveAzul.props = obj => {
+AveAzul.props = (obj) => {
   const keys = Object.keys(obj);
-  const values = keys.map(k => obj[k]);
+  const values = keys.map((k) => obj[k]);
 
-  return AveAzul.all(values).then(results => {
+  return AveAzul.all(values).then((results) => {
     const resolved = {};
     keys.forEach((k, i) => {
       resolved[k] = results[i];
@@ -295,24 +310,7 @@ AveAzul.props = obj => {
  * @returns {Object} Deferred object with promise, resolve, and reject methods
  */
 AveAzul.defer = () => {
-  const deferred = xaa.makeDefer();
-  deferred.promise = AveAzul.resolve(deferred.promise);
-  return deferred;
-};
-
-/**
- * Bluebird-style promisify() for converting callback-style functions to promises
- * @param {Function} fn - Function to promisify
- * @param {Object} [options] - Options object
- * @param {Object} [options.context] - `this` context to bind the function to
- * @returns {Function} Promisified function that returns an AveAzul promise
- */
-AveAzul.promisify = (fn, options = {}) => {
-  const promisified = nodePromisify(fn);
-  if (options.context) {
-    return (...args) => AveAzul.resolve(promisified.apply(options.context, args));
-  }
-  return (...args) => AveAzul.resolve(promisified(...args));
+  return xaa.makeDefer(AveAzul);
 };
 
 /**
@@ -321,7 +319,9 @@ AveAzul.promisify = (fn, options = {}) => {
  * @param {Function} fn - Iterator function to call for each item
  * @returns {Promise} Promise that resolves when iteration is complete
  */
-AveAzul.each = (items, fn) => AveAzul.resolve(xaa.each(items, fn));
+AveAzul.each = function (items, fn) {
+  return AveAzul.resolve(items).each(fn);
+};
 
 /**
  * Bluebird-style reduce() for array reduction
@@ -330,124 +330,132 @@ AveAzul.each = (items, fn) => AveAzul.resolve(xaa.each(items, fn));
  * @param {*} [initialValue] - Optional initial value
  * @returns {Promise} Promise that resolves with the final reduced value
  */
-AveAzul.reduce = (array, fn, initialValue) => {
-  const hasInitial = arguments.length > 2;
-  const len = array.length;
-
-  return AveAzul.resolve().then(async () => {
-    let value = hasInitial ? initialValue : array[0];
-    const start = hasInitial ? 0 : 1;
-
-    for (let i = start; i < len; i++) {
-      value = await fn(value, array[i], i, len);
-    }
+AveAzul.reduce = function (array, ...args) {
+  return AveAzul.resolve(array).reduce(...args);
+};
 
-    return value;
+/**
+ * Bluebird-style promisify() for converting callback-based functions to promises
+ * @param {Function} fn - Function to promisify
+ * @param {Object} [options] - Options object
+ * @returns {Function} Promisified function
+ */
+AveAzul.promisify = (fn, options) => {
+  return promisify(fn, {
+    ...options,
+    Promise: AveAzul,
   });
 };
 
 /**
- * Bluebird-style throw() that returns a rejected promise with the given reason
- * @param {*} reason - Value to reject the promise with
- * @returns {Promise} Promise that rejects with the given reason
+ * Bluebird-style promisifyAll() for converting callback-based functions to promises
+ * @param {Object} target - Object to promisify
+ * @param {Object} [options] - Options object
+ * @returns {Object} Object with promisified methods
  */
-AveAzul.throw = reason => AveAzul.reject(reason);
+AveAzul.promisifyAll = (target, options) => {
+  return promisifyAll(target, { ...options, Promise: AveAzul });
+};
 
 /**
- * Bluebird-style promisifyAll() for converting all methods of an object or class to promise-based versions
- * Similar to Bluebird's Promise.promisifyAll()
- * 
- * @param {Object|Function} target - The object or class to promisify
- * @param {Object} [options] - Configuration options
- * @param {string} [options.suffix='Async'] - Suffix to append to promisified method names
- * @param {Function} [options.filter] - Filter function to determine which methods to promisify
- * @param {Function} [options.promisifier] - Custom function to handle promisification
- * @param {boolean} [options.multiArgs=false] - Whether to support multiple callback arguments
- * @param {boolean} [options.excludeMain=false] - Whether to exclude promisifying the main object/class
- * @param {Object} [options.context] - The context (this) to use when calling methods
- * @returns {Object|Function} The promisified object or class
- * @throws {TypeError} If target is null, undefined, or not an object/function
- * 
- * @example
- * // Promisify an object
- * const obj = {
- *   method(cb) { cb(null, 'result'); }
- * };
- * AveAzul.promisifyAll(obj);
- * const result = await obj.methodAsync();
- * 
- * @example
- * // Promisify a class
- * class MyClass {
- *   method(cb) { cb(null, 'result'); }
- * }
- * AveAzul.promisifyAll(MyClass);
- * const instance = new MyClass();
- * const result = await instance.methodAsync();
- * 
- * @example
- * // With custom options
- * const obj = {
- *   method(cb) { cb(null, 'result1', 'result2'); }
- * };
- * AveAzul.promisifyAll(obj, {
- *   suffix: 'Promise',
- *   multiArgs: true,
- *   filter: (name) => name === 'method'
- * });
- * const [result1, result2] = await obj.methodPromise();
+ * Bluebird-style method() for creating a method that returns a promise
+ * @param {Function} fn - Function to create a method for
+ * @returns {Function} Method function that returns a promise
  */
-AveAzul.promisifyAll = (target, options = {}) => {
-  const {
-    suffix = 'Async',
-    filter = (name, func, targetObj, passedOptions) => {
-      return (
-        typeof func === 'function' &&
-        !func.name.startsWith('_') &&
-        !func.name.startsWith('promisify') &&
-        !func.name.startsWith('promisifyAll')
-      );
-    },
-    promisifier = (fn, context, multiArgs) => {
-      if (multiArgs) {
-        return (...args) => {
-          return new AveAzul((resolve, reject) => {
-            args.push((err, ...results) => {
-              if (err) reject(err);
-              else resolve(results);
-            });
-            fn.apply(context, args);
-          });
-        };
+AveAzul.method = (fn) => {
+  return function (...args) {
+    return new AveAzul((resolve, reject) => {
+      try {
+        const result = fn.call(this, ...args);
+        resolve(result);
+      } catch (error) {
+        reject(error);
       }
-      return AveAzul.promisify(fn, { context });
-    },
-    multiArgs = false,
-    excludeMain = false,
-    context = target
-  } = options;
-
-  if (target == null || (typeof target !== 'object' && typeof target !== 'function')) {
-    throw new TypeError('target must be an object');
-  }
+    });
+  };
+};
 
-  const targetObj = target.prototype || target;
-  const keys = Object.getOwnPropertyNames(targetObj);
+/**
+ * Bluebird-style using() for resource management. There is only a static version of this method.
+ * After the handler finish and returns, regardless of whether it resolves or rejects, the resources will be disposed.
+ *
+ * @param {Disposer|Array<Disposer>} resources - Resource disposers, either an array of disposers or a variadic argument list
+ * @param {Function} handler - Handler function that will receive the resources as arguments
+ * @returns {Promise} Promise that resolves with handler result
+ */
+AveAzul.using = (resources, ...args) => {
+  if (args.length === 0) {
+    throw new TypeError("resrouces and handler function required");
+  }
 
-  for (const key of keys) {
-    const func = targetObj[key];
-    if (filter(key, func, targetObj, options)) {
-      const promisifiedKey = key + suffix;
-      targetObj[promisifiedKey] = promisifier(func, context, multiArgs);
+  if (Array.isArray(resources)) {
+    if (args.length > 1) {
+      throw new TypeError(
+        "only two arguments are allowed when passing an array of resources"
+      );
     }
+    return using(resources, args[0], AveAzul, true);
   }
+  const handler = args.pop();
+  return using([resources, ...args], handler, AveAzul, false);
+};
 
-  if (!excludeMain && typeof target === 'function') {
-    target.promisify = AveAzul.promisify;
-    target.promisifyAll = AveAzul.promisifyAll;
+/**
+ * Bluebird-style join() for joining promises
+ *
+ * @param {...Promise} args - Promises to join
+ * @param {Function} handler - Handler function to apply to the joined results
+ * @returns {Promise} Promise that resolves with the handler's return value
+ */
+AveAzul.join = function (...args) {
+  if (args.length > 1 && typeof args.at(-1) === "function") {
+    const handler = args.pop();
+    return AveAzul.all(args).then((results) => handler(...results));
+  } else {
+    return AveAzul.all(args);
   }
-
-  return target;
 };
 
+function fromCallback(fn, options) {
+  return new AveAzul((resolve, reject) => {
+    try {
+      fn((err, ...args) => {
+        if (err) {
+          reject(err);
+        } else {
+          if (options && options.multiArgs) {
+            resolve(args);
+          } else {
+            resolve(args[0]);
+          }
+        }
+      });
+    } catch (err) {
+      reject(err);
+    }
+  });
+}
+
+AveAzul.fromNode = fromCallback;
+
+/**
+ * Bluebird-style fromCallback() for converting callback-based functions to promises
+ * @param {Function} fn - Function to convert
+ * @param {Object} [options] - Options object
+ * @returns {Promise} Promise that resolves with the function's return value
+ */
+AveAzul.fromCallback = fromCallback;
+
+/**
+ * @description
+ * When fatal error and AveAzul needs to crash the process,
+ * this method is used to throw the error.
+ *
+ * @param {Error} error - The error to throw.
+ */
+AveAzul.___throwUncaughtError = triggerUncaughtException;
+
 module.exports = AveAzul;
+
+const { setupNotImplemented } = require("./not-implemented");
+setupNotImplemented(AveAzul);

package/lib/disposer.js

@@ -0,0 +1,14 @@
+"use strict";
+
+/**
+ * Disposer class for resource cleanup
+ * @private
+ */
+class Disposer {
+  constructor(fn, promise) {
+    this._data = fn; // The cleanup function
+    this._promise = promise; // The promise that resolves to the resource
+  }
+}
+
+module.exports.Disposer = Disposer;

package/lib/not-implemented.js

@@ -0,0 +1,97 @@
+"use strict";
+
+function createNotImplemented(name) {
+  return function () {
+    const msg = name + " Not implemented in aveazul";
+    console.error(msg);
+    throw new Error(msg);
+  };
+}
+
+function createInstanceNotImplemented(AveAzul) {
+  const methods = [
+    "spread",
+    "error",
+    "bind",
+    "join",
+    "try",
+    "method",
+    "isFulfilled",
+    "isRejected",
+    "isPending",
+    "value",
+    "reason",
+    "props",
+    "any",
+    "some",
+    "map",
+    "reduce",
+    "filter",
+    "each",
+    "mapSeries",
+    "tap",
+    "tapCatch",
+    "catchThrow",
+    "catchReturn",
+    "get",
+    "throw",
+    "call",
+  ];
+
+  const proto = AveAzul.prototype;
+  const ret = [];
+  for (const method of methods) {
+    if (!proto[method]) {
+      ret.push(method);
+      proto[method] = createNotImplemented("instance " + method);
+    }
+  }
+  return ret;
+}
+
+function createStaticNotImplemented(AveAzul) {
+  const methods = [
+    "join",
+    "try",
+    "method",
+    "resolve",
+    "reject",
+    "all",
+    "props",
+    "any",
+    "some",
+    "map",
+    "filter",
+    "each",
+    "mapSeries",
+    "race",
+    "promisify",
+    "promisifyAll",
+    "fromNode",
+    "fromCallback",
+    "delay",
+    "coroutine",
+    "config",
+  ];
+  const ret = [];
+  for (const method of methods) {
+    if (!AveAzul[method]) {
+      ret.push(method);
+      AveAzul[method] = createNotImplemented("static " + method);
+    }
+  }
+  return ret;
+}
+
+function setupNotImplemented(AveAzul) {
+  const instance = createInstanceNotImplemented(AveAzul);
+  const staticMethods = createStaticNotImplemented(AveAzul);
+  AveAzul.__notImplementedInstance = instance;
+  AveAzul.__notImplementedStatic = staticMethods;
+}
+
+module.exports = {
+  createInstanceNotImplemented,
+  createStaticNotImplemented,
+  setupNotImplemented,
+};

package/lib/promisify-all.js

@@ -0,0 +1,132 @@
+"use strict";
+
+const { promisify } = require("./promisify");
+const {
+  isIdentifier,
+  isClass,
+  isConstructor,
+  isPromisified,
+  getObjectKeys,
+  isExcludedPrototype,
+} = require("./util");
+
+const defaultSuffix = "Async";
+
+const defaultFilter = function (name) {
+  return isIdentifier(name) && name.charAt(0) !== "_" && name !== "constructor";
+};
+
+const defaultPromisifier = (fn, _defaultPromisifier, options) => {
+  return promisify(fn, {
+    ...options,
+    copyProps: false,
+  });
+};
+
+const excludedClasses = [Array, Object, Function];
+
+// Helper function to determine if a class extends from any excluded class
+function isExcludedClass(obj) {
+  if (excludedClasses.includes(obj)) {
+    return true;
+  }
+
+  // Check if obj extends from any excluded class using instanceof
+  if (typeof obj === "function" && obj.prototype) {
+    // Check if prototype is instance of any excluded class
+    for (const excludedClass of excludedClasses) {
+      if (obj.prototype instanceof excludedClass) {
+        return true;
+      }
+    }
+  }
+
+  return false;
+}
+
+function promisifyAll2(obj, options) {
+  if (isExcludedClass(obj)) {
+    return;
+  }
+
+  const allKeys = getObjectKeys(obj);
+
+  for (const key of allKeys) {
+    const value = obj[key];
+    const promisifiedKey = key + options.suffix;
+    const passesDefaultFilter =
+      options.filter === defaultFilter ? true : defaultFilter(key, value, obj);
+    if (
+      isConstructor(value) ||
+      typeof value !== "function" ||
+      isPromisified(value) ||
+      obj[promisifiedKey] ||
+      !options.filter(key, value, obj, passesDefaultFilter)
+    ) {
+      continue;
+    }
+
+    if (key.endsWith(options.suffix)) {
+      throw new TypeError(
+        "Cannot promisify an API that has normal methods with '%s'-suffix\u000a\u000a    See http://goo.gl/MqrFmX\u000a".replace(
+          "%s",
+          options.suffix
+        )
+      );
+    }
+
+    obj[promisifiedKey] = options.promisifier(value, defaultPromisifier, {
+      context: obj,
+      copyProps: false,
+      multiArgs: options.multiArgs,
+      Promise: options.Promise,
+    });
+  }
+}
+
+function promisifyAll(target, _options) {
+  if (typeof target !== "function" && typeof target !== "object") {
+    throw new TypeError(
+      "the target of promisifyAll must be an object or a function"
+    );
+  }
+
+  const options = {
+    suffix: defaultSuffix,
+    filter: defaultFilter,
+    promisifier: defaultPromisifier,
+    Promise: global.Promise,
+    ..._options,
+  };
+
+  const suffix = options.suffix;
+
+  if (!isIdentifier(suffix)) {
+    throw new RangeError(
+      "suffix must be a valid identifier\u000a\u000a    See http://goo.gl/MqrFmX\u000a"
+    );
+  }
+
+  const allKeys = getObjectKeys(target);
+
+  for (const key of allKeys) {
+    const value = target[key];
+    if (
+      value &&
+      key !== "constructor" &&
+      !key.startsWith("_") &&
+      isClass(value)
+    ) {
+      const proto = Object.getPrototypeOf(value);
+      if (!isExcludedPrototype(proto)) {
+        promisifyAll2(proto, options);
+      }
+
+      promisifyAll2(value, options);
+    }
+  }
+
+  promisifyAll2(target, options);
+}
+
+module.exports.promisifyAll = promisifyAll;

package/lib/promisify.js

@@ -0,0 +1,70 @@
+"use strict";
+
+const { copyOwnProperties, isPromisified } = require("./util");
+
+module.exports.promisify = function promisify(fn, _options) {
+  if (typeof fn !== "function") {
+    throw new TypeError("expecting a function but got " + {}.toString.call(fn));
+  }
+
+  if (isPromisified(fn)) {
+    return fn;
+  }
+
+  const options = {
+    Promise: global.Promise,
+    multiArgs: false,
+    copyProps: true,
+    suffix: "",
+    ..._options,
+  };
+
+  const Promise = options.Promise;
+  const multiArgs = !!options.multiArgs;
+
+  const promisifiedFn = (...args) => {
+    return new Promise((resolve, reject) => {
+      // add a callback to the end of the arguments to transfer the result to the promise
+      args.push((err, ...values) => {
+        if (err) {
+          return reject(err);
+        }
+        if (multiArgs) {
+          resolve(values);
+        } else {
+          resolve(values[0]);
+        }
+      });
+
+      // call the original function with the updated args
+      fn.call(options.context, ...args);
+    });
+  };
+
+  if (options.copyProps) {
+    copyOwnProperties(fn, promisifiedFn);
+  }
+
+  Object.defineProperty(promisifiedFn, "__isPromisified__", {
+    value: true,
+    writable: false,
+    enumerable: false,
+    configurable: true,
+  });
+
+  Object.defineProperty(promisifiedFn, "length", {
+    value: fn.length,
+    writable: false,
+    enumerable: false,
+    configurable: false,
+  });
+
+  Object.defineProperty(promisifiedFn, "name", {
+    value: fn.name + options.suffix,
+    writable: false,
+    enumerable: false,
+    configurable: false,
+  });
+
+  return promisifiedFn;
+};

package/lib/using.js

@@ -0,0 +1,128 @@
+"use strict";
+
+const { Disposer } = require("./disposer");
+const { isPromise } = require("./util");
+
+const SYM_FN_DISPOSE = Symbol("fnDispose");
+/**
+ * @description
+ * The using function is a utility function that allows you to acquire resources,
+ * process them, and then dispose of them in an error-safe manner.
+ *
+ * @param {Array} resources - An array of resources to acquire.
+ * @param {Function} handler - A function that will be called with the acquired resources.
+ * @param {Promise} Promise - The Promise implementation to use. AveAzul or Bluebird.
+ * @param {boolean} asArray - Whether to return the result as an array.
+ * @returns {Promise} A promise that resolves to the result of the handler function.
+ */
+function using(resources, handler, Promise, asArray) {
+  if (typeof handler !== "function") {
+    throw new TypeError("handler must be a function");
+  }
+
+  // resources is guaranateed to be an array of disposer, promise like, or any value
+  // first process all resources by mapping the resources array:
+  // 1. if it's a disposer, get its promise and resolve its value
+  // 2. if it's a promise like, get its value
+  // 3. otherwise, return the value
+  // Expect Promise to be AveAzul or Bluebird that has map method
+  const acquisitionErrors = [];
+
+  const acquireResources = () => {
+    const promiseRes = resources.map((resource) => {
+      // if it's a promise-like, wait for its resolved value
+      if (isPromise(resource)) {
+        return { ___promise: resource };
+      }
+      return resource;
+    });
+
+    return Promise.map(promiseRes, async (resource) => {
+      if (
+        resource &&
+        (resource instanceof Disposer ||
+          (resource._promise && typeof resource._data === "function"))
+      ) {
+        try {
+          const res = await resource._promise;
+          resource._result = res;
+          resource[SYM_FN_DISPOSE] = resource._data;
+        } catch (error) {
+          acquisitionErrors.push(error);
+          resource._error = error;
+        }
+        return resource;
+      }
+
+      // if it's a promise like, wait for its resolved value
+      if (resource && resource.___promise) {
+        try {
+          const res = await resource.___promise;
+          resource._result = res;
+        } catch (error) {
+          acquisitionErrors.push(error);
+          resource._error = error;
+        }
+        return resource;
+      }
+
+      return { _result: resource };
+    });
+  };
+
+  const disposeResources = (processedResources) => {
+    const errors = [];
+    return Promise.each(processedResources, async (resource) => {
+      // dispose all resources that were acquired without errors
+      if (resource && resource[SYM_FN_DISPOSE]) {
+        try {
+          await resource[SYM_FN_DISPOSE](resource._result);
+        } catch (error) {
+          errors.push(error);
+        }
+      }
+    }).finally(() => {
+      if (errors.length > 0) {
+        Promise.___throwUncaughtError(
+          new AggregateError(errors, "cleanup resources failed", errors)
+        );
+      }
+    });
+  };
+
+  return acquireResources().then((processedResources) => {
+    if (acquisitionErrors.length > 0) {
+      return disposeResources(processedResources).tap(() => {
+        throw acquisitionErrors[0];
+      });
+    }
+
+    // now collect all the results into an array
+    const results = [];
+    for (const resource of processedResources) {
+      results.push(resource._result);
+    }
+
+    let handlerPromise;
+
+    try {
+      // now call the handler with the results
+      handlerPromise = Promise.resolve(
+        asArray ? handler(results) : handler(...results)
+      );
+    } catch (error) {
+      // catch sync error from handler
+      handlerPromise = Promise.reject(error);
+    }
+
+    return handlerPromise
+      .tap(() => {
+        return disposeResources(processedResources);
+      })
+      .tapCatch(() => {
+        return disposeResources(processedResources);
+      });
+  });
+}
+
+module.exports.using = using;

package/lib/util.js

@@ -0,0 +1,194 @@
+"use strict";
+
+/**
+ * Determines if a function is a class (either ES6 class or ES5 constructor function)
+ * This function performs several checks to identify different class patterns:
+ * 1. ES6 classes with the 'class' keyword
+ * 2. Constructor functions (ES5 classes) with prototype methods
+ *
+ * @param {*} fn - The value to check
+ * @returns {boolean} - True if the function is a class, false otherwise
+ */
+const thisAssignmentPattern = /this\s*\.\s*\S+\s*=/;
+function isClass(fn) {
+  try {
+    if (typeof fn === "function") {
+      const keys = Object.getOwnPropertyNames(fn.prototype);
+
+      const fnStr = fn.toString();
+      const es6Class = fnStr.startsWith("class ") || /^class\s+/.test(fnStr);
+      const hasMethods = keys.length > 1;
+      const hasMethodsOtherThanConstructor =
+        keys.length > 0 && !(keys.length === 1 && keys[0] === "constructor");
+      const hasThisAssignmentAndStaticMethods =
+        thisAssignmentPattern.test(fnStr) &&
+        Object.getOwnPropertyNames(fn).length > 0;
+
+      if (
+        es6Class ||
+        hasMethods ||
+        hasMethodsOtherThanConstructor ||
+        hasThisAssignmentAndStaticMethods
+      ) {
+        return true;
+      }
+    }
+    return false;
+  } catch (e) {
+    return false;
+  }
+}
+
+const rident = /^[a-z$_][a-z$_0-9]*$/i;
+function isIdentifier(str) {
+  return rident.test(str);
+}
+
+function isConstructor(func) {
+  if (!func) {
+    return false;
+  }
+  const proto = func.prototype;
+  return (
+    !!proto &&
+    !!proto.constructor &&
+    !!proto.constructor.name &&
+    proto.constructor.name === func.name
+  );
+}
+
+/**
+ * Prop filtering code copied from bluebird/js/release
+ */
+const noCopyProps = [
+  "arity",
+  "length",
+  "name",
+  "arguments",
+  "caller",
+  "callee",
+  "prototype",
+  "__isPromisified__",
+];
+const noCopyPropsPattern = new RegExp("^(?:" + noCopyProps.join("|") + ")$");
+
+function propsFilter(key) {
+  return !noCopyPropsPattern.test(key);
+}
+
+function copyOwnProperties(source, target, filter = propsFilter) {
+  const names = Object.getOwnPropertyNames(source);
+
+  for (const name of names) {
+    if (filter(name)) {
+      Object.defineProperty(
+        target,
+        name,
+        Object.getOwnPropertyDescriptor(source, name)
+      );
+    }
+  }
+}
+
+/**
+ * Copied from bluebird/js/release/util.js
+ * @param {*} fn
+ * @returns {boolean}
+ */
+function isPromisified(fn) {
+  try {
+    return fn.__isPromisified__ === true;
+  } catch (e) {
+    return false;
+  }
+}
+
+/**
+ * Determines if an object is a Promise instance
+ * @param {*} obj - The object to check
+ * @returns {boolean} - True if the object is a Promise instance, false otherwise
+ */
+function isPromise(obj) {
+  return (
+    obj instanceof Promise ||
+    (obj != null &&
+      typeof obj === "object" &&
+      typeof obj.then === "function" &&
+      typeof obj.catch === "function")
+  );
+}
+
+// istanbul ignore next
+const emptyFatArrow = () => {};
+// istanbul ignore next
+const emptyFunction = function () {};
+
+const defaultExcluded = [
+  Object.getPrototypeOf(Array), // Array.prototype
+  Object.getPrototypeOf(Object), // Object.prototype
+  Object.getPrototypeOf(Function), // Function.prototype
+  Object.getPrototypeOf([]),
+  Object.getPrototypeOf({}),
+  Object.getPrototypeOf(emptyFatArrow),
+  Object.getPrototypeOf(emptyFunction),
+];
+
+function isExcludedPrototype(proto) {
+  return defaultExcluded.includes(proto);
+}
+
+/**
+ * Gets all property keys from an object and its prototype chain, excluding standard
+ * prototypes like Object.prototype, Array.prototype, and Function.prototype
+ *
+ * @param {Object} target - The target object to get keys from
+ * @param {Array} [excludedPrototypes=[]] - An array of prototype objects to exclude keys from
+ * @returns {Array<string>} - Array of property keys
+ */
+function getObjectKeys(target, excludedPrototypes = []) {
+  const excluded =
+    excludedPrototypes.length > 0 ? excludedPrototypes : defaultExcluded;
+
+  // Get own properties
+  const ownKeys = Object.getOwnPropertyNames(target);
+
+  // Get prototype properties, excluding those from excluded prototypes
+  let protoKeys = [];
+  let currentProto = Object.getPrototypeOf(target);
+
+  // Walk up the prototype chain until we hit null or an excluded prototype
+  while (currentProto && !excluded.includes(currentProto)) {
+    protoKeys = [...protoKeys, ...Object.getOwnPropertyNames(currentProto)];
+    currentProto = Object.getPrototypeOf(currentProto);
+  }
+
+  // Combine own properties and prototype properties
+  return [...protoKeys, ...ownKeys];
+}
+
+/**
+ * Triggers an uncaught exception in a safe way by scheduling it on the next event loop tick
+ * This is used for fatal errors that should crash the process
+ * @param {Error} error - The error to throw
+ */
+function triggerUncaughtException(error) {
+  if (!(error instanceof Error)) {
+    error = new Error(String(error));
+  }
+
+  // Use setTimeout with 0ms delay to throw on the next event loop tick
+  // This ensures the current execution context completes first
+  setTimeout(() => {
+    throw error;
+  }, 0);
+}
+
+module.exports.copyOwnProperties = copyOwnProperties;
+module.exports.isClass = isClass;
+module.exports.isIdentifier = isIdentifier;
+module.exports.isConstructor = isConstructor;
+module.exports.isPromisified = isPromisified;
+module.exports.isPromise = isPromise;
+module.exports.triggerUncaughtException = triggerUncaughtException;
+module.exports.getObjectKeys = getObjectKeys;
+module.exports.isExcludedPrototype = isExcludedPrototype;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aveazul",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "Bluebird-like APIs in extended native Promise",
   "main": "lib/aveazul.js",
   "homepage": "https://github.com/jchip/aveazul",
@@ -8,7 +8,12 @@
   "scripts": {
     "test": "jest test",
     "test:watch": "jest test --watch",
-    "test:coverage": "jest test --coverage"
+    "test:coverage": "jest test --coverage",
+    "test:bluebird": "USE_BLUEBIRD=true jest test",
+    "test:debug": "node --inspect-brk node_modules/.bin/jest --runInBand --no-coverage",
+    "test:debug:bluebird": "USE_BLUEBIRD=true node --inspect-brk node_modules/.bin/jest --runInBand --no-coverage",
+    "jest": "jest --no-coverage",
+    "jest:bluebird": "USE_BLUEBIRD=true jest --no-coverage"
   },
   "author": "Joel Chen",
   "files": [
@@ -28,6 +33,8 @@
     "xaa": "^1.7.3"
   },
   "devDependencies": {
-    "jest": "^29.7.0"
+    "bluebird": "^3.7.2",
+    "jest": "^29.7.0",
+    "rimraf": "^3.0.1"
   }
 }