aveazul 0.1.1 → 0.1.3

package/README.md

@@ -1,18 +1,6 @@
 # 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.
-
-## Requirements
-
-- 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
+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)).
 
 ## Installation
 
@@ -25,63 +13,88 @@ npm install aveazul
 ```javascript
 const AveAzul = require('aveazul');
 
-// Create a new promise
-const promise = new AveAzul((resolve, reject) => {
-  setTimeout(() => resolve('result'), 1000);
-});
+// Basic Promise usage
+const promise = new AveAzul((resolve) => resolve(42));
+promise.then(value => console.log(value)); // 42
 
-// Use Bluebird-style methods
-promise
-  .tap(value => console.log('Got:', value))
-  .delay(500)
-  .then(value => console.log('After delay:', value));
-
-// 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]
+  .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));
+
+// Promisify all methods of an object
+const obj = {
+  method(cb) { cb(null, 'result'); }
+};
+AveAzul.promisifyAll(obj);
+obj.methodAsync().then(result => console.log(result)); // 'result'
 ```
 
 ## 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
+- `delay(ms)` - Delay resolution
+- `timeout(ms, message?)` - Reject after specified time
 - `try(fn)` - Wrap sync/async functions
-- `props(obj)` - Handle object properties
-- `reduce(fn, initialValue?)` - Reduce array
+- `props(obj)` - Resolve object properties
+- `catchIf(predicate, fn)` - Catch specific errors
+- `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
 
 ### 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
+- `each(items, fn)` - Iterate over array elements
+- `reduce(array, fn, initialValue?)` - Reduce array elements
+- `throw(reason)` - Return rejected promise
+- `promisifyAll(target, options?)` - Convert all methods of an object/class to promises
+
+### 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
+- `excludeMain` (default: false) - Whether to exclude promisifying the main object/class
+- `context` - The context (this) to use when calling methods
+
+## 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

@@ -353,4 +353,101 @@ AveAzul.reduce = (array, fn, initialValue) => {
  */
 AveAzul.throw = reason => AveAzul.reject(reason);
 
+/**
+ * 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();
+ */
+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);
+          });
+        };
+      }
+      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);
+    }
+  }
+
+  if (!excludeMain && typeof target === 'function') {
+    target.promisify = AveAzul.promisify;
+    target.promisifyAll = AveAzul.promisifyAll;
+  }
+
+  return target;
+};
+
 module.exports = AveAzul;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "aveazul",
-  "version": "0.1.1",
-  "description": "Extend native Promise with bluebird like APIs for Node.js",
+  "version": "0.1.3",
+  "description": "Bluebird-like APIs in extended native Promise",
   "main": "lib/aveazul.js",
   "homepage": "https://github.com/jchip/aveazul",
   "license": "Apache-2.0",