aveazul 1.0.0 → 1.0.2

package/README.md

@@ -1,4 +1,4 @@
-# AveAzul
+# AveAzul.js
 
 AveAzul ("Blue Bird" in Spanish) serves as a near drop-in replacement for Bluebird. It's built on native Promise, by extending it with the familiar utility methods from Bluebird.
 
@@ -14,6 +14,10 @@ Further, if you like Bluebird's API but want to use native Promises, AveAzul giv
 - Implements most commonly used Bluebird methods
 - Comprehensive test suite ensuring compatibility
 
+## Requirements
+
+- node.js version >= 12
+
 ## Installation
 
 ```bash
@@ -143,6 +147,7 @@ Key differences to be aware of:
 - `all()` - Like Promise.all(), resolves when all promises resolve, rejects if any reject
 - `call(propertyName, ...args)` - Call a method on the resolved value with the provided arguments
 - `asCallback(callback, options?)` - Register a Node-style callback that handles the resolution or rejection
+- `error(handler)` - Like catch(), but only catches operational errors, letting programmer errors bubble up
 
 ### Static Methods
 
@@ -164,6 +169,10 @@ Key differences to be aware of:
 - `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
 
+### Error Types
+
+- `AveAzul.OperationalError` - Error type for representing expected operational errors (network failures, validation errors, etc.)
+
 ### PromisifyAll Options
 
 - `suffix` (default: 'Async') - Suffix to append to promisified method names

package/lib/any.js

@@ -0,0 +1,55 @@
+"use strict";
+
+const { toArray, isPromise } = require("./util");
+const { AggregateError } = require("@jchip/error");
+
+function addStaticAny(AveAzul, force = false) {
+  if (force || !AveAzul.any) {
+    AveAzul.any = function (args) {
+      try {
+        args = toArray(args);
+      } catch (error) {
+        return AveAzul.reject(error);
+      }
+
+      if (args.length === 0) {
+        return AveAzul.reject(
+          new RangeError(
+            "Input array must contain at least 1 items but contains only 0 items"
+          )
+        );
+      }
+
+      return new AveAzul((resolve, reject) => {
+        const len = args.length;
+        let settled = false;
+        const errors = [];
+
+        const doFinish = (value) => {
+          if (settled) return;
+          settled = true;
+          resolve(value);
+        };
+
+        const addError = (err) => {
+          errors.push(err);
+          if (!settled && errors.length >= len) {
+            settled = true;
+            reject(new AggregateError(errors));
+          }
+        };
+
+        for (let i = 0; i < len; i++) {
+          const arg = args[i];
+          if (isPromise(arg)) {
+            arg.then(doFinish, addError);
+          } else {
+            doFinish(arg);
+          }
+        }
+      });
+    };
+  }
+}
+
+module.exports.addStaticAny = addStaticAny;

package/lib/aveazul.js

@@ -5,8 +5,9 @@ const { promisify } = require("./promisify");
 const { promisifyAll } = require("./promisify-all");
 const { Disposer } = require("./disposer");
 const { using } = require("./using");
-const { isPromise, triggerUncaughtException } = require("./util");
-
+const { isPromise, triggerUncaughtException, toArray } = require("./util");
+const { AggregateError } = require("@jchip/error");
+const { OperationalError, isOperationalError } = require("./operational-error");
 /**
  * @fileoverview
  * AveAzul ("Blue Bird" in Spanish) - Extended Promise class that provides Bluebird like utility methods
@@ -86,20 +87,7 @@ class AveAzul extends Promise {
    */
   any() {
     return this.then((args) => {
-      if (!Array.isArray(args)) {
-        // Check if args is iterable
-        if (args != null && typeof args[Symbol.iterator] === "function") {
-          // Convert iterable to array, must do this to get the length, in order
-          // to detect if too many errors occurred and completion is impossible.
-          args = Array.from(args);
-        } else {
-          throw new TypeError(
-            "expecting an array or an iterable object but got " + args
-          );
-        }
-      }
-
-      return AveAzul.any(args);
+      return AveAzul.any(toArray(args));
     });
   }
 
@@ -140,7 +128,12 @@ class AveAzul extends Promise {
    * @returns {Promise} Promise that rejects if timeout occurs
    */
   timeout(ms, message = "operation timed out") {
-    return AveAzul.resolve(xaa.timeout(ms, message).run(this));
+    return xaa
+      .timeout(ms, message, {
+        Promise: AveAzul,
+        TimeoutError: OperationalError,
+      })
+      .run(this);
   }
 
   /**
@@ -291,18 +284,7 @@ class AveAzul extends Promise {
 
   some(count) {
     return this.then((args) => {
-      if (!Array.isArray(args)) {
-        // Check if args is iterable
-        if (args != null && typeof args[Symbol.iterator] === "function") {
-          // Convert iterable to array, must do this to get the length, in order
-          // to detect if too many errors occurred and completion is impossible.
-          args = Array.from(args);
-        } else {
-          throw new TypeError(
-            "expecting an array or an iterable object but got " + args
-          );
-        }
-      }
+      args = toArray(args);
 
       return new AveAzul((resolve, reject) => {
         // If too many promises are rejected so that the promise can never become fulfilled,
@@ -314,17 +296,23 @@ class AveAzul extends Promise {
         const results = [];
         const len = args.length;
 
+        let settled = false;
+
         const addDone = (result) => {
+          if (settled) return;
           results.push(result);
           if (results.length >= count) {
+            settled = true;
             // Resolve with exactly count results to match Bluebird's behavior
             resolve(results.slice(0, count));
           }
         };
 
         const addError = (err) => {
+          if (settled) return;
           errors.push(err);
           if (len - errors.length < count) {
+            settled = true;
             reject(new AggregateError(errors, `aggregate error`));
           }
         };
@@ -348,19 +336,7 @@ class AveAzul extends Promise {
    */
   all() {
     return this.then((value) => {
-      if (!Array.isArray(value)) {
-        // Check if value is iterable
-        if (value != null && typeof value[Symbol.iterator] === "function") {
-          // Convert iterable to array
-          value = Array.from(value);
-        } else {
-          throw new TypeError(
-            "expecting an array or an iterable object but got " + value
-          );
-        }
-      }
-
-      return AveAzul.all(value);
+      return AveAzul.all(toArray(value));
     });
   }
 
@@ -420,6 +396,21 @@ class AveAzul extends Promise {
       return obj[methodName].call(obj, ...args);
     });
   }
+
+  /**
+   * Catches only operational errors and passes them to the handler.
+   * Programmer errors (non-operational) are rethrown.
+   * @param {Function} handler - Function to handle operational errors
+   * @returns {Promise} - Promise with the error handled or rethrown
+   */
+  error(handler) {
+    return this.catch((err) => {
+      if (isOperationalError(err)) {
+        return handler(err);
+      }
+      throw err;
+    });
+  }
 }
 
 /**
@@ -584,7 +575,7 @@ AveAzul.using = (resources, ...args) => {
  * @returns {Promise} Promise that resolves with the handler's return value
  */
 AveAzul.join = function (...args) {
-  if (args.length > 1 && typeof args.at(-1) === "function") {
+  if (args.length > 1 && typeof args[args.length - 1] === "function") {
     const handler = args.pop();
     return AveAzul.all(args).then((results) => handler(...results));
   } else {
@@ -641,8 +632,14 @@ AveAzul.some = function (promises, count) {
   return AveAzul.resolve(promises).some(count);
 };
 
+const { addStaticAny } = require("./any");
+addStaticAny(AveAzul);
+
 // Setup the not implemented methods
 const { setupNotImplemented } = require("./not-implemented");
 setupNotImplemented(AveAzul);
 
+// Add these static properties after the class definition
+AveAzul.OperationalError = OperationalError;
+
 module.exports = AveAzul;

package/lib/not-implemented.js

@@ -13,7 +13,6 @@ function createInstanceNotImplemented(AveAzul) {
     "then",
     "spread",
     "catch",
-    "error",
     "finally",
     "bind",
     "isFulfilled",

package/lib/operational-error.js

@@ -0,0 +1,46 @@
+"use strict";
+
+/**
+ * OperationalError class for representing errors that are expected during normal operation
+ * Similar to Bluebird's OperationalError
+ */
+class OperationalError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "OperationalError";
+    this.isOperational = true;
+
+    // Capture stack trace
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+  }
+}
+
+/**
+ * Check if an error is an operational error
+ * @param {*} error - Error to check
+ * @returns {boolean} True if the error is operational
+ */
+function isOperationalError(error) {
+  if (!error || typeof error !== "object") return false;
+  return error instanceof OperationalError || error.isOperational === true;
+}
+
+/**
+ * Check if an error is a programmer error (unexpected, likely a bug)
+ * @param {*} error - Error to check
+ * @returns {boolean} True if the error is a programmer error
+ */
+function isProgrammerError(error) {
+  if (!error || typeof error !== "object") return false;
+  return !isOperationalError(error);
+}
+
+// Only export the OperationalError class
+module.exports = {
+  OperationalError,
+  // Internal utilities used by AveAzul.prototype.error
+  isOperationalError,
+  isProgrammerError,
+};

package/lib/promisify-all.js

@@ -4,16 +4,14 @@ const { promisify } = require("./promisify");
 const {
   isIdentifier,
   isClass,
-  isConstructor,
   isPromisified,
-  getObjectKeys,
-  isExcludedPrototype,
+  getObjectDataKeys,
 } = require("./util");
 
 const defaultSuffix = "Async";
 
 const defaultFilter = function (name) {
-  return isIdentifier(name) && name.charAt(0) !== "_" && name !== "constructor";
+  return isIdentifier(name) && name.charAt(0) !== "_" && name !== "constructor" && !name.endsWith("Sync");
 };
 
 const defaultPromisifier = (fn, _defaultPromisifier, options) => {
@@ -23,33 +21,9 @@ const defaultPromisifier = (fn, _defaultPromisifier, options) => {
   });
 };
 
-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);
+  const allKeys = getObjectDataKeys(obj);
 
   for (const key of allKeys) {
     const value = obj[key];
@@ -57,7 +31,6 @@ function promisifyAll2(obj, options) {
     const passesDefaultFilter =
       options.filter === defaultFilter ? true : defaultFilter(key, value, obj);
     if (
-      isConstructor(value) ||
       typeof value !== "function" ||
       isPromisified(value) ||
       obj[promisifiedKey] ||
@@ -76,19 +49,16 @@ function promisifyAll2(obj, options) {
     }
 
     obj[promisifiedKey] = options.promisifier(value, defaultPromisifier, {
-      context: obj,
+      // context: obj, // promisified function should get the binded object using this
       copyProps: false,
-      multiArgs: options.multiArgs,
-      Promise: options.Promise,
+      ...options
     });
   }
 }
 
 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"
-    );
+    throw new TypeError("the target of promisifyAll must be an object or a function");
   }
 
   const options = {
@@ -107,21 +77,12 @@ function promisifyAll(target, _options) {
     );
   }
 
-  const allKeys = getObjectKeys(target);
+  const allKeys = getObjectDataKeys(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);
-      }
-
+    if (value && key !== "constructor" && !key.startsWith("_") && isClass(value)) {
+      promisifyAll2(value.prototype, options);
       promisifyAll2(value, options);
     }
   }

package/lib/promisify.js

@@ -22,7 +22,7 @@ module.exports.promisify = function promisify(fn, _options) {
   const Promise = options.Promise;
   const multiArgs = !!options.multiArgs;
 
-  const promisifiedFn = (...args) => {
+  const promisifiedFn = function (...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) => {
@@ -37,7 +37,7 @@ module.exports.promisify = function promisify(fn, _options) {
       });
 
       // call the original function with the updated args
-      fn.call(options.context, ...args);
+      fn.call(options.context || this, ...args);
     });
   };
 

package/lib/using.js

@@ -2,6 +2,7 @@
 
 const { Disposer } = require("./disposer");
 const { isPromise } = require("./util");
+const { AggregateError } = require("@jchip/error");
 
 const SYM_FN_DISPOSE = Symbol("fnDispose");
 /**
@@ -28,6 +29,25 @@ function using(resources, handler, Promise, asArray) {
   // Expect Promise to be AveAzul or Bluebird that has map method
   const acquisitionErrors = [];
 
+  // Helper function to process a disposer
+  const processDisposer = async (resource, disposer) => {
+    try {
+      const res = await disposer._promise;
+      resource._result = res;
+      resource[SYM_FN_DISPOSE] = disposer._data;
+    } catch (error) {
+      acquisitionErrors.push(error);
+      resource._error = error;
+    }
+    return resource;
+  };
+
+  // Helper to check if something is a disposer
+  const isDisposer = (obj) =>
+    obj &&
+    (obj instanceof Disposer ||
+      (obj._promise && typeof obj._data === "function"));
+
   const acquireResources = () => {
     const promiseRes = resources.map((resource) => {
       // if it's a promise-like, wait for its resolved value
@@ -38,27 +58,21 @@ function using(resources, handler, Promise, asArray) {
     });
 
     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 directly a disposer
+      if (isDisposer(resource)) {
+        return processDisposer(resource, 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;
+          // Check if the resolved value is a disposer
+          if (isDisposer(res)) {
+            return processDisposer(resource, res);
+          } else {
+            resource._result = res;
+          }
         } catch (error) {
           acquisitionErrors.push(error);
           resource._error = error;

package/lib/util.js

@@ -11,32 +11,25 @@
  */
 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;
-      }
+    try {
+        if (typeof fn === "function") {
+            const keys = Object.getOwnPropertyNames(fn.prototype);
+
+            const hasMethods = keys.length > 1;
+            const hasMethodsOtherThanConstructor = keys.length > 0 &&
+                !(keys.length === 1 && keys[0] === "constructor");
+            const hasThisAssignmentAndStaticMethods =
+                thisAssignmentPattern.test(fn + "") && Object.getOwnPropertyNames (fn).length > 0;
+
+            if (hasMethods || hasMethodsOtherThanConstructor ||
+                hasThisAssignmentAndStaticMethods) {
+                return true;
+            }
+        }
+        return false;
+    } catch (e) {
+        return false;
     }
-    return false;
-  } catch (e) {
-    return false;
-  }
 }
 
 const rident = /^[a-z$_][a-z$_0-9]*$/i;
@@ -44,18 +37,6 @@ 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
@@ -81,11 +62,7 @@ function copyOwnProperties(source, target, filter = propsFilter) {
 
   for (const name of names) {
     if (filter(name)) {
-      Object.defineProperty(
-        target,
-        name,
-        Object.getOwnPropertyDescriptor(source, name)
-      );
+      Object.defineProperty(target, name, Object.getOwnPropertyDescriptor(source, name));
     }
   }
 }
@@ -118,52 +95,66 @@ 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
  *
- * @param {Object} target - The target object to get keys from
+ * @param {Object} obj - 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);
+function getObjectDataKeys(obj, excludedProtos = []) {
+  const excludedPrototypes = [
+    Array.prototype,
+    Object.prototype,
+    Function.prototype,
+    ...excludedProtos,
+  ];
+
+  const isExcludedProto = function (val) {
+    for (const protoVal of excludedPrototypes) {
+      if (protoVal === val) {
+        return true;
+      }
+    }
+    return false;
+  };
+
+  const ret = [];
+  const visitedKeys = Object.create(null);
+
+  /* copied from bluebird/js/release/util.js and modified */
+  while (obj && !isExcludedProto(obj)) {
+    let keys;
+    try {
+      keys = Object.getOwnPropertyNames(obj);
+    } catch (e) {
+      /* istanbul ignore next */
+      return ret;
+    }
 
-  // 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);
+    for (const key of keys) {
+      /* istanbul ignore if */
+      if (visitedKeys[key]) {
+        /* istanbul ignore next */
+        continue;
+      }
+      visitedKeys[key] = true;
+      const desc = Object.getOwnPropertyDescriptor(obj, key);
+      /**
+       * When desc.get && desc.set are falsy, it means the property is a data
+       * property that holds an actual value, rather than being computed dynamically
+       * through getter/setter functions.
+       */
+      /* istanbul ignore next */
+      if (desc && !desc.get && !desc.set) {
+        ret.push(key);
+      }
+    }
+    obj = Object.getPrototypeOf(obj);
   }
 
-  // Combine own properties and prototype properties
-  return [...protoKeys, ...ownKeys];
+  return ret;
 }
 
 /**
@@ -183,12 +174,26 @@ function triggerUncaughtException(error) {
   }, 0);
 }
 
+function toArray(args) {
+  if (!Array.isArray(args)) {
+    // Check if args is iterable
+    if (args != null && typeof args[Symbol.iterator] === "function") {
+      // Convert iterable to array, must do this to get the length, in order
+      // to detect if too many errors occurred and completion is impossible.
+      args = Array.from(args);
+    } else {
+      throw new TypeError("expecting an array or an iterable object but got " + args);
+    }
+  }
+
+  return args;
+}
+
 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;
+module.exports.getObjectDataKeys = getObjectDataKeys;
+module.exports.toArray = toArray;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aveazul",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "Bluebird drop-in replacement built on native Promise",
   "main": "lib/aveazul.js",
   "homepage": "https://github.com/jchip/aveazul",
@@ -53,18 +53,24 @@
     "any",
     "props",
     "filter",
-    "reduce"
+    "reduce",
+    "aveazul",
+    "aveazul.js"
   ],
   "repository": {
     "type": "git",
     "url": "git+https://github.com/jchip/aveazul.git"
   },
   "dependencies": {
-    "xaa": "^1.7.3"
+    "@jchip/error": "^1.0.3",
+    "xaa": "^1.8.0"
   },
   "devDependencies": {
     "bluebird": "^3.7.2",
-    "jest": "^29.7.0",
+    "jest": "^28.0.0",
     "rimraf": "^3.0.1"
+  },
+  "engines": {
+    "node": ">=12.0.0"
   }
 }