aveazul 1.0.0 → 1.0.1

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

@@ -76,7 +76,7 @@ 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,

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

@@ -183,6 +183,23 @@ 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;
@@ -192,3 +209,4 @@ module.exports.isPromise = isPromise;
 module.exports.triggerUncaughtException = triggerUncaughtException;
 module.exports.getObjectKeys = getObjectKeys;
 module.exports.isExcludedPrototype = isExcludedPrototype;
+module.exports.toArray = toArray;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aveazul",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "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"
   }
 }