aveazul 1.0.2 → 2.0.0

package/lib/not-implemented.js

@@ -1,110 +0,0 @@
-"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 = [
-    "then",
-    "spread",
-    "catch",
-    "finally",
-    "bind",
-    "isFulfilled",
-    "isRejected",
-    "isPending",
-    "isCancelled",
-    "value",
-    "reason",
-    "all",
-    "props",
-    "any",
-    "some",
-    "map",
-    "reduce",
-    "filter",
-    "each",
-    "mapSeries",
-    "disposer",
-    "asCallback",
-    "delay",
-    "timeout",
-    "cancel",
-    "tap",
-    "tapCatch",
-    "call",
-    "get",
-    "return",
-    "throw",
-    "catchReturn",
-    "catchThrow",
-    "reflect",
-    "suppressUnhandledRejections",
-    "done",
-  ];
-
-  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",
-    "props",
-    "any",
-    "some",
-    "map",
-    "reduce",
-    "filter",
-    "each",
-    "mapSeries",
-    "race",
-    "using",
-    "promisify",
-    "promisifyAll",
-    "fromCallback",
-    "delay",
-    "coroutine",
-    "coroutine.addYieldHandler",
-    "getNewLibraryCopy",
-    "noConflict",
-    "setScheduler",
-  ];
-  const ret = [];
-  for (const method of methods) {
-    if (!AveAzul[method]) {
-      ret.push(method);
-      AveAzul[method] = createNotImplemented("static " + method);
-    }
-  }
-  return ret;
-}
-
-function setupNotImplemented(AveAzul) {
-  const instanceMethods = createInstanceNotImplemented(AveAzul);
-  const staticMethods = createStaticNotImplemented(AveAzul);
-  AveAzul.__notImplementedInstance = instanceMethods;
-  AveAzul.__notImplementedStatic = staticMethods;
-}
-
-module.exports = {
-  createInstanceNotImplemented,
-  createStaticNotImplemented,
-  setupNotImplemented,
-};

package/lib/operational-error.js

@@ -1,46 +0,0 @@
-"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

@@ -1,93 +0,0 @@
-"use strict";
-
-const { promisify } = require("./promisify");
-const {
-  isIdentifier,
-  isClass,
-  isPromisified,
-  getObjectDataKeys,
-} = require("./util");
-
-const defaultSuffix = "Async";
-
-const defaultFilter = function (name) {
-  return isIdentifier(name) && name.charAt(0) !== "_" && name !== "constructor" && !name.endsWith("Sync");
-};
-
-const defaultPromisifier = (fn, _defaultPromisifier, options) => {
-  return promisify(fn, {
-    ...options,
-    copyProps: false,
-  });
-};
-
-
-function promisifyAll2(obj, options) {
-  const allKeys = getObjectDataKeys(obj);
-
-  for (const key of allKeys) {
-    const value = obj[key];
-    const promisifiedKey = key + options.suffix;
-    const passesDefaultFilter =
-      options.filter === defaultFilter ? true : defaultFilter(key, value, obj);
-    if (
-      typeof value !== "function" ||
-      isPromisified(value) ||
-      obj[promisifiedKey] ||
-      !options.filter(key, value, obj, passesDefaultFilter)
-    ) {
-      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, // promisified function should get the binded object using this
-      copyProps: false,
-      ...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");
-  }
-
-  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 = getObjectDataKeys(target);
-
-  for (const key of allKeys) {
-    const value = target[key];
-    if (value && key !== "constructor" && !key.startsWith("_") && isClass(value)) {
-      promisifyAll2(value.prototype, options);
-      promisifyAll2(value, options);
-    }
-  }
-
-  promisifyAll2(target, options);
-}
-
-module.exports.promisifyAll = promisifyAll;

package/lib/promisify.js

@@ -1,70 +0,0 @@
-"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 = 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) => {
-        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 || this, ...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

@@ -1,142 +0,0 @@
-"use strict";
-
-const { Disposer } = require("./disposer");
-const { isPromise } = require("./util");
-const { AggregateError } = require("@jchip/error");
-
-const SYM_FN_DISPOSE = Symbol("fnDispose");
-/**
- * @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 = [];
-
-  // 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
-      if (isPromise(resource)) {
-        return { ___promise: resource };
-      }
-      return resource;
-    });
-
-    return Promise.map(promiseRes, async (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;
-          // 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;
-        }
-        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 && 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 AggregateError(errors, "cleanup resources failed", errors)
-        );
-      }
-    });
-  };
-
-  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 handlerPromise;
-
-    try {
-      // now call the handler with the results
-      handlerPromise = Promise.resolve(
-        asArray ? handler(results) : handler(...results)
-      );
-    } catch (error) {
-      // catch sync error from handler
-      handlerPromise = Promise.reject(error);
-    }
-
-    return handlerPromise
-      .tap(() => {
-        return disposeResources(processedResources);
-      })
-      .tapCatch(() => {
-        return disposeResources(processedResources);
-      });
-  });
-}
-
-module.exports.using = using;

package/lib/util.js

@@ -1,199 +0,0 @@
-"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
- */
-const thisAssignmentPattern = /this\s*\.\s*\S+\s*=/;
-function isClass(fn) {
-    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;
-    }
-}
-
-const rident = /^[a-z$_][a-z$_0-9]*$/i;
-function isIdentifier(str) {
-  return rident.test(str);
-}
-
-
-/**
- * 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")
-  );
-}
-
-/**
- * Gets all property keys from an object and its prototype chain, excluding standard
- * prototypes like Object.prototype, Array.prototype, and Function.prototype
- *
- * @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 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;
-    }
-
-    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);
-  }
-
-  return ret;
-}
-
-/**
- * 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);
-}
-
-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.isPromisified = isPromisified;
-module.exports.isPromise = isPromise;
-module.exports.triggerUncaughtException = triggerUncaughtException;
-module.exports.getObjectDataKeys = getObjectDataKeys;
-module.exports.toArray = toArray;