aveazul 0.1.2 → 0.1.4

package/README.md

@@ -1,18 +1,10 @@
 # AveAzul
 
-AveAzul ("Blue Bird" in Spanish) is a Promise extension library that provides Bluebird-like utility methods built on top of native Promises. The name is a Spanish play on words referencing Bluebird.
+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)).
 
-## Requirements
+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.
 
-- Node.js 16 or higher
-
-## Features
-
-- Extends native Promise with Bluebird-like utility methods
-- Built on top of the efficient `xaa` library for async operations
-- Zero external runtime dependencies (other than `xaa`)
-- TypeScript-friendly
-- Familiar Bluebird-style API
+Do you prefer Bluebird's API with native Promises? AveAzul gives you both - familiar Bluebird methods built on native Promise.
 
 ## Installation
 
@@ -23,65 +15,109 @@ npm install aveazul
 ## Usage
 
 ```javascript
-const AveAzul = require('aveazul');
-
-// Create a new promise
-const promise = new AveAzul((resolve, reject) => {
-  setTimeout(() => resolve('result'), 1000);
-});
+const AveAzul = require("aveazul");
 
-// Use Bluebird-style methods
-promise
-  .tap(value => console.log('Got:', value))
-  .delay(500)
-  .then(value => console.log('After delay:', value));
+// Basic Promise usage
+const promise = new AveAzul((resolve) => resolve(42));
+promise.then((value) => console.log(value)); // 42
 
-// Static helpers
-AveAzul.delay(1000, 'hello')
-  .then(value => console.log(value));
-
-// Array operations
+// Utility methods
 AveAzul.resolve([1, 2, 3])
-  .map(x => x * 2)
-  .filter(x => x > 4)
-  .then(result => console.log(result)); // [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 readFile = AveAzul.promisify(fs.readFile);
+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");
+  },
+};
+AveAzul.promisifyAll(obj);
+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
+});
 ```
 
 ## API
 
 ### Instance Methods
 
-- `tap(fn)` - Execute side effects in a chain
+- `tap(fn)` - Execute side effects and return original value
 - `filter(fn)` - Filter array elements
-- `map(fn)` - Map array elements
-- `return(value)` - Inject a value into the chain
+- `map(fn)` - Transform array elements
+- `return(value)` - Inject a new value
 - `each(fn)` - Iterate over array elements
-- `delay(ms)` - Delay execution
-- `timeout(ms, message?)` - Set operation timeout
-- `try(fn)` - Wrap sync/async functions
-- `props(obj)` - Handle object properties
-- `reduce(fn, initialValue?)` - Reduce array
+- `delay(ms)` - Delay resolution
+- `timeout(ms, message?)` - Reject after specified time
+- `props(obj)` - Resolve object properties
+- `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)` - Get nested property
+- `get(propertyPath)` - Retrieve property value
+- `disposer(fn)` - Create a disposer for use with AveAzul.using() for resource cleanup
 
 ### Static Methods
 
-- `AveAzul.delay(ms, value?)` - Create delayed promise
-- `AveAzul.map(array, fn)` - Map array elements
-- `AveAzul.try(fn)` - Wrap function execution
-- `AveAzul.props(obj)` - Handle object properties
-- `AveAzul.defer()` - Create deferred promise
-- `AveAzul.promisify(fn, options?)` - Promisify callback functions
-- `AveAzul.each(items, fn)` - Iterate over items
-- `AveAzul.reduce(array, fn, initialValue?)` - Reduce array
-- `AveAzul.throw(reason)` - Create rejected promise
+- `delay(ms, value?)` - Resolve after specified time
+- `map(value, fn)` - Transform array elements
+- `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 (preserves original function properties)
+- `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
+
+### PromisifyAll Options
+
+- `suffix` (default: 'Async') - Suffix to append to promisified method names
+- `filter` - Filter function to determine which methods to promisify
+- `promisifier` - Custom function to handle promisification
+- `multiArgs` (default: false) - Whether to support multiple callback arguments
+
+## Development
+
+```bash
+# Install dependencies
+npm install
+
+# Run tests
+npm test
+npm run test:watch
+npm run test:coverage
+```
 
 ## License
 
-Apache 2.0
+Apache-2.0
 
-## Dependencies
+## Author
 
-- [xaa](https://github.com/jchip/xaa) - Efficient async/await helpers
+Joel Chen

package/lib/aveazul.js

@@ -1,8 +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
  * This implementation is inspired by and provides similar APIs to the Bluebird Promise library,
@@ -28,7 +31,7 @@ class AveAzul extends Promise {
    * @returns {Promise} Promise that resolves with the original value
    */
   tap(fn) {
-    return this.then(value => {
+    return this.then((value) => {
       fn(value);
       return value;
     });
@@ -41,7 +44,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 +54,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 +74,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 +94,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 +103,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 +112,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 +133,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 +147,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 +190,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,27 +206,23 @@ 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);
-      }
-
-      let result = value;
-      const props = String(propertyPath).split(".");
-
-      for (const prop of props) {
-        if (result == null) {
-          throw new TypeError("Cannot read property '" + prop + "' of " + result);
-        }
-        result = result[prop];
-      }
+  get(key) {
+    return this.then((value) => value[key]);
+  }
 
-      return result;
-    });
+  /**
+   * 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);
   }
 }
 
@@ -270,18 +256,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 +281,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 +290,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 +301,83 @@ 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);
+    });
+  };
+};
 
-  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);
-    }
+/**
+ * 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");
   }
 
-  if (!excludeMain && typeof target === 'function') {
-    target.promisify = AveAzul.promisify;
-    target.promisifyAll = AveAzul.promisifyAll;
+  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);
   }
-
-  return target;
+  const handler = args.pop();
+  return using([resources, ...args], handler, AveAzul, false);
 };
 
+/**
+ * @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;

package/lib/disposer.js

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

package/lib/promisify-all.js

@@ -0,0 +1,135 @@
+"use strict";
+
+const { promisify } = require("./promisify");
+const {
+  isIdentifier,
+  isClass,
+  isConstructor,
+  isPromisified,
+  getObjectKeys,
+} = 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 excludedPrototypes = [
+  Object.getPrototypeOf(Array),
+  Object.getPrototypeOf(Object),
+  Object.getPrototypeOf(Function),
+];
+
+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, excludedPrototypes);
+
+  for (const key of allKeys) {
+    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
+        )
+      );
+    }
+    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;
+    }
+    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, excludedPrototypes);
+
+  for (const key of allKeys) {
+    const value = target[key];
+    if (
+      value &&
+      key !== "constructor" &&
+      !key.startsWith("_") &&
+      isClass(value)
+    ) {
+      const proto = Object.getPrototypeOf(value);
+      if (!excludedPrototypes.includes(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,123 @@
+"use strict";
+
+const { Disposer } = require("./disposer");
+const { isPromise } = require("./util");
+
+/**
+ * @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 instanceof Disposer) {
+        try {
+          const res = await resource._promise;
+          resource._result = res;
+        } 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._error && resource.hasOwnProperty("_result")) {
+        if (resource instanceof Disposer) {
+          try {
+            await resource._data(resource._result);
+          } catch (error) {
+            errors.push(error);
+          }
+        }
+      }
+    }).finally(() => {
+      if (errors.length > 0) {
+        Promise.___throwUncaughtError(new Error("cleanup resources failed"));
+      }
+    });
+  };
+
+  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 handlerResult;
+    let handlerSyncError;
+    try {
+      // now call the handler with the results
+      if (asArray) {
+        handlerResult = handler(results);
+      } else {
+        handlerResult = handler(...results);
+      }
+    } catch (error) {
+      // catch sync error from handler
+      handlerSyncError = error;
+    }
+
+    return disposeResources(processedResources).then(() => {
+      if (handlerSyncError) {
+        throw handlerSyncError;
+      }
+      return handlerResult;
+    });
+  });
+}
+
+module.exports.using = using;

package/lib/util.js

@@ -0,0 +1,189 @@
+"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
+ */
+function isClass(fn) {
+  // Early return for non-functions or null/undefined
+  if (!fn || typeof fn !== "function") return false;
+
+  // Method 1: Check for ES6 class syntax
+  // This detects class declarations and class expressions
+  try {
+    const fnStr = fn.toString();
+    if (fnStr.startsWith("class ") || /^class\s+/.test(fnStr)) {
+      return true;
+    }
+  } catch (e) {
+    // Ignore errors that might occur when calling toString()
+    // Some objects might have custom toString implementations that throw
+    return false;
+  }
+
+  // Method 2: Check for constructor functions (ES5 class pattern)
+  // A proper constructor has its .prototype.constructor pointing back to itself
+  if (fn.prototype && fn.prototype.constructor === fn) {
+    // Additional validation to filter out regular functions
+    // that happen to have the correct prototype structure
+
+    // Check if the prototype has any methods other than constructor
+    // This is a strong indicator of a class-like structure
+    const hasOwnMethods = Object.getOwnPropertyNames(fn.prototype).some(
+      (name) =>
+        name !== "constructor" && typeof fn.prototype[name] === "function"
+    );
+
+    // If it has prototype methods OR has static properties/methods
+    // Either condition suggests it's being used as a class
+    return hasOwnMethods || Object.getOwnPropertyNames(fn).length > 0;
+  }
+
+  // Not a class by any of our detection methods
+  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")
+  );
+}
+
+const defaultExcluded = [
+  Object.getPrototypeOf(Array), // Array.prototype
+  Object.getPrototypeOf(Object), // Object.prototype
+  Object.getPrototypeOf(Function), // Function.prototype
+];
+
+/**
+ * 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;

package/package.json

@@ -1,14 +1,17 @@
 {
   "name": "aveazul",
-  "version": "0.1.2",
-  "description": "Extend native Promise with bluebird like APIs for Node.js",
+  "version": "0.1.4",
+  "description": "Bluebird-like APIs in extended native Promise",
   "main": "lib/aveazul.js",
   "homepage": "https://github.com/jchip/aveazul",
   "license": "Apache-2.0",
   "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"
   },
   "author": "Joel Chen",
   "files": [
@@ -28,6 +31,8 @@
     "xaa": "^1.7.3"
   },
   "devDependencies": {
-    "jest": "^29.7.0"
+    "bluebird": "^3.7.2",
+    "jest": "^29.7.0",
+    "rimraf": "^3.0.1"
   }
 }