aveazul 0.1.4 → 0.1.5

package/README.md

@@ -58,6 +58,17 @@ AveAzul.using(getResource(), (resource) => {
   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
@@ -72,6 +83,7 @@ AveAzul.using(getResource(), (resource) => {
 - `delay(ms)` - Delay resolution
 - `timeout(ms, message?)` - Reject after specified time
 - `props(obj)` - Resolve object properties
+- `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
@@ -88,12 +100,15 @@ AveAzul.using(getResource(), (resource) => {
 - `props(obj)` - Resolve object properties
 - `defer()` - Create a deferred promise
 - `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
 

package/lib/aveazul.js

@@ -6,6 +6,7 @@ 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,
@@ -31,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;
     });
   }
@@ -222,8 +223,36 @@ class AveAzul extends Promise {
     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)
+      );
+    }
+
+    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];
+          }
+        }
+        return fn(...args);
+      } else {
+        return fn(args);
+      }
+    });
+  }
 }
 
 /**
@@ -371,6 +400,52 @@ AveAzul.using = (resources, ...args) => {
   return using([resources, ...args], handler, AveAzul, false);
 };
 
+/**
+ * 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);
+  }
+};
+
+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,
@@ -381,3 +456,6 @@ AveAzul.using = (resources, ...args) => {
 AveAzul.___throwUncaughtError = triggerUncaughtException;
 
 module.exports = AveAzul;
+
+const { setupNotImplemented } = require("./not-implemented");
+setupNotImplemented(AveAzul);

package/lib/disposer.js

@@ -5,8 +5,8 @@
  * @private
  */
 class Disposer {
-  constructor(data, promise) {
-    this._data = data; // The cleanup function
+  constructor(fn, promise) {
+    this._data = fn; // The cleanup function
     this._promise = promise; // The promise that resolves to the resource
   }
 }

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

@@ -7,6 +7,7 @@ const {
   isConstructor,
   isPromisified,
   getObjectKeys,
+  isExcludedPrototype,
 } = require("./util");
 
 const defaultSuffix = "Async";
@@ -22,12 +23,6 @@ const defaultPromisifier = (fn, _defaultPromisifier, options) => {
   });
 };
 
-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
@@ -54,17 +49,9 @@ function promisifyAll2(obj, options) {
     return;
   }
 
-  const allKeys = getObjectKeys(obj, excludedPrototypes);
+  const allKeys = getObjectKeys(obj);
 
   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 =
@@ -78,6 +65,16 @@ function promisifyAll2(obj, options) {
     ) {
       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,
@@ -110,7 +107,7 @@ function promisifyAll(target, _options) {
     );
   }
 
-  const allKeys = getObjectKeys(target, excludedPrototypes);
+  const allKeys = getObjectKeys(target);
 
   for (const key of allKeys) {
     const value = target[key];
@@ -121,7 +118,7 @@ function promisifyAll(target, _options) {
       isClass(value)
     ) {
       const proto = Object.getPrototypeOf(value);
-      if (!excludedPrototypes.includes(proto)) {
+      if (!isExcludedPrototype(proto)) {
         promisifyAll2(proto, options);
       }
 

package/lib/using.js

@@ -3,6 +3,7 @@
 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,
@@ -37,10 +38,15 @@ function using(resources, handler, Promise, asArray) {
     });
 
     return Promise.map(promiseRes, async (resource) => {
-      if (resource instanceof Disposer) {
+      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;
@@ -68,18 +74,18 @@ function using(resources, handler, Promise, asArray) {
     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);
-          }
+      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 Error("cleanup resources failed"));
+        Promise.___throwUncaughtError(
+          new AggregateError(errors, "cleanup resources failed", errors)
+        );
       }
     });
   };
@@ -97,26 +103,25 @@ function using(resources, handler, Promise, asArray) {
       results.push(resource._result);
     }
 
-    let handlerResult;
-    let handlerSyncError;
+    let handlerPromise;
+
     try {
       // now call the handler with the results
-      if (asArray) {
-        handlerResult = handler(results);
-      } else {
-        handlerResult = handler(...results);
-      }
+      handlerPromise = Promise.resolve(
+        asArray ? handler(results) : handler(...results)
+      );
     } catch (error) {
       // catch sync error from handler
-      handlerSyncError = error;
+      handlerPromise = Promise.reject(error);
     }
 
-    return disposeResources(processedResources).then(() => {
-      if (handlerSyncError) {
-        throw handlerSyncError;
-      }
-      return handlerResult;
-    });
+    return handlerPromise
+      .tap(() => {
+        return disposeResources(processedResources);
+      })
+      .tapCatch(() => {
+        return disposeResources(processedResources);
+      });
   });
 }
 

package/lib/util.js

@@ -9,43 +9,34 @@
  * @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) {
-  // 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;
+    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) {
-    // 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;
@@ -127,12 +118,25 @@ function isPromise(obj) {
   );
 }
 
+// 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
@@ -187,3 +191,4 @@ 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.4",
+  "version": "0.1.5",
   "description": "Bluebird-like APIs in extended native Promise",
   "main": "lib/aveazul.js",
   "homepage": "https://github.com/jchip/aveazul",
@@ -11,7 +11,9 @@
     "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"
+    "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": [