@feathersjs/client 5.0.0-pre.14 → 5.0.0-pre.15

package/CHANGELOG.md

@@ -3,6 +3,14 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [5.0.0-pre.15](https://github.com/feathersjs/feathers/compare/v5.0.0-pre.14...v5.0.0-pre.15) (2021-11-27)
+
+**Note:** Version bump only for package @feathersjs/client
+
+
+
+
+
 # [5.0.0-pre.14](https://github.com/feathersjs/feathers/compare/v5.0.0-pre.13...v5.0.0-pre.14) (2021-10-13)
 
 **Note:** Version bump only for package @feathersjs/client

package/dist/core.js

@@ -1045,7 +1045,7 @@ var index_1 = __webpack_require__(/*! ./hooks/index */ "../feathers/lib/hooks/in
 
 var service_1 = __webpack_require__(/*! ./service */ "../feathers/lib/service.js");
 
-var legacy_1 = __webpack_require__(/*! ./hooks/legacy */ "../feathers/lib/hooks/legacy.js");
+var regular_1 = __webpack_require__(/*! ./hooks/regular */ "../feathers/lib/hooks/regular.js");
 
 var debug = (0, dependencies_1.createDebug)('@feathersjs/feathers');
 
@@ -1066,7 +1066,7 @@ var Feathers = /*#__PURE__*/function (_dependencies_1$Event) {
     _this.version = version_1.default;
     _this._isSetup = false;
     _this.appHooks = _defineProperty({}, dependencies_1.HOOKS, [events_1.eventHook]);
-    _this.legacyHooks = (0, legacy_1.enableLegacyHooks)(_assertThisInitialized(_this));
+    _this.regularHooks = (0, regular_1.enableRegularHooks)(_assertThisInitialized(_this));
     return _this;
   }
 
@@ -1164,10 +1164,10 @@ var Feathers = /*#__PURE__*/function (_dependencies_1$Event) {
     value: function hooks(hookMap) {
       var _this3 = this;
 
-      var legacyMap = hookMap;
+      var regularMap = hookMap;
 
-      if (legacyMap.before || legacyMap.after || legacyMap.error) {
-        return this.legacyHooks(legacyMap);
+      if (regularMap.before || regularMap.after || regularMap.error) {
+        return this.regularHooks(regularMap);
       }
 
       if (Array.isArray(hookMap)) {
@@ -1382,30 +1382,50 @@ function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.g
 Object.defineProperty(exports, "__esModule", ({
   value: true
 }));
-exports.hookMixin = exports.FeathersHookManager = exports.createContext = exports.fromErrorHooks = exports.fromBeforeHook = exports.fromAfterHook = void 0;
+exports.hookMixin = exports.FeathersHookManager = exports.createContext = exports.fromErrorHooks = exports.fromErrorHook = exports.fromAfterHooks = exports.fromAfterHook = exports.fromBeforeHooks = exports.fromBeforeHook = void 0;
 
 var dependencies_1 = __webpack_require__(/*! ../dependencies */ "../feathers/lib/dependencies.js");
 
 var service_1 = __webpack_require__(/*! ../service */ "../feathers/lib/service.js");
 
-var legacy_1 = __webpack_require__(/*! ./legacy */ "../feathers/lib/hooks/legacy.js");
+var regular_1 = __webpack_require__(/*! ./regular */ "../feathers/lib/hooks/regular.js");
 
+var regular_2 = __webpack_require__(/*! ./regular */ "../feathers/lib/hooks/regular.js");
+
+Object.defineProperty(exports, "fromBeforeHook", ({
+  enumerable: true,
+  get: function get() {
+    return regular_2.fromBeforeHook;
+  }
+}));
+Object.defineProperty(exports, "fromBeforeHooks", ({
+  enumerable: true,
+  get: function get() {
+    return regular_2.fromBeforeHooks;
+  }
+}));
 Object.defineProperty(exports, "fromAfterHook", ({
   enumerable: true,
   get: function get() {
-    return legacy_1.fromAfterHook;
+    return regular_2.fromAfterHook;
   }
 }));
-Object.defineProperty(exports, "fromBeforeHook", ({
+Object.defineProperty(exports, "fromAfterHooks", ({
+  enumerable: true,
+  get: function get() {
+    return regular_2.fromAfterHooks;
+  }
+}));
+Object.defineProperty(exports, "fromErrorHook", ({
   enumerable: true,
   get: function get() {
-    return legacy_1.fromBeforeHook;
+    return regular_2.fromErrorHook;
   }
 }));
 Object.defineProperty(exports, "fromErrorHooks", ({
   enumerable: true,
   get: function get() {
-    return legacy_1.fromErrorHooks;
+    return regular_2.fromErrorHooks;
   }
 }));
 
@@ -1444,12 +1464,12 @@ var FeathersHookManager = /*#__PURE__*/function (_dependencies_1$HookM) {
     value: function collectMiddleware(self, args) {
       var app = this.app;
       var appHooks = app.appHooks[dependencies_1.HOOKS].concat(app.appHooks[this.method] || []);
-      var legacyAppHooks = (0, legacy_1.collectLegacyHooks)(this.app, this.method);
+      var regularAppHooks = (0, regular_1.collectRegularHooks)(this.app, this.method);
 
       var middleware = _get(_getPrototypeOf(FeathersHookManager.prototype), "collectMiddleware", this).call(this, self, args);
 
-      var legacyHooks = (0, legacy_1.collectLegacyHooks)(self, this.method);
-      return [].concat(_toConsumableArray(appHooks), _toConsumableArray(legacyAppHooks), _toConsumableArray(middleware), _toConsumableArray(legacyHooks));
+      var regularHooks = (0, regular_1.collectRegularHooks)(self, this.method);
+      return [].concat(_toConsumableArray(appHooks), _toConsumableArray(regularAppHooks), _toConsumableArray(middleware), _toConsumableArray(regularHooks));
     }
   }, {
     key: "initializeContext",
@@ -1481,7 +1501,8 @@ function hookMixin(service, path, options) {
   }
 
   var app = this;
-  var serviceMethodHooks = (0, service_1.getHookMethods)(service, options).reduce(function (res, method) {
+  var hookMethods = (0, service_1.getHookMethods)(service, options);
+  var serviceMethodHooks = hookMethods.reduce(function (res, method) {
     var _FeathersHookManager;
 
     var params = service_1.defaultServiceArguments[method] || ['data', 'params'];
@@ -1491,18 +1512,29 @@ function hookMixin(service, path, options) {
       method: method,
       service: service,
       event: null,
-      type: null
+      type: null,
+
+      get statusCode() {
+        var _a;
+
+        return (_a = this.http) === null || _a === void 0 ? void 0 : _a.statusCode;
+      },
+
+      set statusCode(value) {
+        (this.http || (this.http = {})).statusCode = value;
+      }
+
     });
     return res;
   }, {});
-  var handleLegacyHooks = (0, legacy_1.enableLegacyHooks)(service);
+  var handleRegularHooks = (0, regular_1.enableRegularHooks)(service, hookMethods);
   (0, dependencies_1.hooks)(service, serviceMethodHooks);
 
   service.hooks = function (hookOptions) {
     var _this2 = this;
 
     if (hookOptions.before || hookOptions.after || hookOptions.error) {
-      return handleLegacyHooks.call(this, hookOptions);
+      return handleRegularHooks.call(this, hookOptions);
     }
 
     if (Array.isArray(hookOptions)) {
@@ -1528,16 +1560,14 @@ exports.hookMixin = hookMixin;
 
 /***/ }),
 
-/***/ "../feathers/lib/hooks/legacy.js":
-/*!***************************************!*\
-  !*** ../feathers/lib/hooks/legacy.js ***!
-  \***************************************/
+/***/ "../feathers/lib/hooks/regular.js":
+/*!****************************************!*\
+  !*** ../feathers/lib/hooks/regular.js ***!
+  \****************************************/
 /***/ (function(__unused_webpack_module, exports, __webpack_require__) {
 
 
 
-function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
-
 function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
 
 function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
@@ -1552,6 +1582,8 @@ function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o =
 
 function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
 
+function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
 function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
 
 function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
@@ -1561,29 +1593,24 @@ function _defineProperty(obj, key, value) { if (key in obj) { Object.definePrope
 Object.defineProperty(exports, "__esModule", ({
   value: true
 }));
-exports.enableLegacyHooks = exports.convertHookData = exports.collectLegacyHooks = exports.fromErrorHooks = exports.fromAfterHook = exports.fromBeforeHook = void 0;
+exports.enableRegularHooks = exports.convertHookData = exports.collectRegularHooks = exports.fromErrorHooks = exports.fromAfterHooks = exports.fromBeforeHooks = exports.fromErrorHook = exports.fromAfterHook = exports.fromBeforeHook = void 0;
 
-var dependencies_1 = __webpack_require__(/*! ../dependencies */ "../feathers/lib/dependencies.js");
+var service_1 = __webpack_require__(/*! ../service */ "../feathers/lib/service.js");
 
-var each = dependencies_1._.each;
+var runHook = function runHook(hook, context, type) {
+  if (type) context.type = type;
+  return Promise.resolve(hook.call(context.self, context)).then(function (res) {
+    if (type) context.type = null;
 
-var mergeContext = function mergeContext(context) {
-  return function (res) {
     if (res && res !== context) {
       Object.assign(context, res);
     }
-
-    return res;
-  };
+  });
 };
 
 function fromBeforeHook(hook) {
   return function (context, next) {
-    context.type = 'before';
-    return Promise.resolve(hook.call(context.self, context)).then(mergeContext(context)).then(function () {
-      context.type = null;
-      return next();
-    });
+    return runHook(hook, context, 'before').then(next);
   };
 }
 
@@ -1592,49 +1619,24 @@ exports.fromBeforeHook = fromBeforeHook;
 function fromAfterHook(hook) {
   return function (context, next) {
     return next().then(function () {
-      context.type = 'after';
-      return hook.call(context.self, context);
-    }).then(mergeContext(context)).then(function () {
-      context.type = null;
+      return runHook(hook, context, 'after');
     });
   };
 }
 
 exports.fromAfterHook = fromAfterHook;
 
-function fromErrorHooks(hooks) {
+function fromErrorHook(hook) {
   return function (context, next) {
     return next().catch(function (error) {
-      var promise = Promise.resolve();
-      context.original = _objectSpread({}, context);
-      context.error = error;
-      context.type = 'error';
-      delete context.result;
-
-      var _iterator = _createForOfIteratorHelper(hooks),
-          _step;
-
-      try {
-        var _loop = function _loop() {
-          var hook = _step.value;
-          promise = promise.then(function () {
-            return hook.call(context.self, context);
-          }).then(mergeContext(context));
-        };
-
-        for (_iterator.s(); !(_step = _iterator.n()).done;) {
-          _loop();
-        }
-      } catch (err) {
-        _iterator.e(err);
-      } finally {
-        _iterator.f();
+      if (context.error !== error || context.result !== undefined) {
+        context.original = _objectSpread({}, context);
+        context.error = error;
+        delete context.result;
       }
 
-      return promise.then(function () {
-        context.type = null;
-
-        if (context.result === undefined) {
+      return runHook(hook, context, 'error').then(function () {
+        if (context.result === undefined && context.error !== undefined) {
           throw context.error;
         }
       });
@@ -1642,99 +1644,179 @@ function fromErrorHooks(hooks) {
   };
 }
 
-exports.fromErrorHooks = fromErrorHooks;
+exports.fromErrorHook = fromErrorHook;
+
+var RunHooks = function RunHooks(hooks) {
+  return function (context) {
+    return hooks.reduce(function (promise, hook) {
+      return promise.then(function () {
+        return runHook(hook, context);
+      });
+    }, Promise.resolve(undefined));
+  };
+};
+
+function fromBeforeHooks(hooks) {
+  return fromBeforeHook(RunHooks(hooks));
+}
+
+exports.fromBeforeHooks = fromBeforeHooks;
+
+function fromAfterHooks(hooks) {
+  return fromAfterHook(RunHooks(hooks));
+}
 
-function collectLegacyHooks(target, method) {
-  var _target$__hooks = target.__hooks,
-      _target$__hooks$befor = _target$__hooks.before[method],
-      before = _target$__hooks$befor === void 0 ? [] : _target$__hooks$befor,
-      _target$__hooks$after = _target$__hooks.after[method],
-      after = _target$__hooks$after === void 0 ? [] : _target$__hooks$after,
-      _target$__hooks$error = _target$__hooks.error[method],
-      error = _target$__hooks$error === void 0 ? [] : _target$__hooks$error;
-  var beforeHooks = before;
+exports.fromAfterHooks = fromAfterHooks;
+
+function fromErrorHooks(hooks) {
+  return fromErrorHook(RunHooks(hooks));
+}
 
-  var afterHooks = _toConsumableArray(after).reverse();
+exports.fromErrorHooks = fromErrorHooks;
 
-  var errorHook = fromErrorHooks(error);
-  return [errorHook].concat(_toConsumableArray(beforeHooks), _toConsumableArray(afterHooks));
+function collectRegularHooks(target, method) {
+  return target.__hooks.hooks[method] || [];
 }
 
-exports.collectLegacyHooks = collectLegacyHooks; // Converts different hook registration formats into the
+exports.collectRegularHooks = collectRegularHooks; // Converts different hook registration formats into the
 // same internal format
 
-function convertHookData(obj) {
-  var hook = {};
+function convertHookData(input) {
+  var result = {};
 
-  if (Array.isArray(obj)) {
-    hook = {
-      all: obj
-    };
-  } else if (_typeof(obj) !== 'object') {
-    hook = {
-      all: [obj]
-    };
+  if (Array.isArray(input)) {
+    result.all = input;
+  } else if (_typeof(input) !== 'object') {
+    result.all = [input];
   } else {
-    each(obj, function (value, key) {
-      hook[key] = !Array.isArray(value) ? [value] : value;
-    });
+    for (var _i = 0, _Object$keys = Object.keys(input); _i < _Object$keys.length; _i++) {
+      var key = _Object$keys[_i];
+      var value = input[key];
+      result[key] = Array.isArray(value) ? value : [value];
+    }
   }
 
-  return hook;
+  return result;
 }
 
-exports.convertHookData = convertHookData; // Add `.hooks` functionality to an object
+exports.convertHookData = convertHookData;
+var types = ['before', 'after', 'error'];
+
+var isType = function isType(value) {
+  return types.includes(value);
+};
+
+var wrappers = {
+  before: fromBeforeHooks,
+  after: fromAfterHooks,
+  error: fromErrorHooks
+};
+
+var createStore = function createStore(methods) {
+  var store = {
+    before: {},
+    after: {},
+    error: {},
+    hooks: {}
+  };
 
-function enableLegacyHooks(obj) {
-  var methods = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : ['find', 'get', 'create', 'update', 'patch', 'remove'];
-  var types = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : ['before', 'after', 'error'];
-  var hookData = {};
-  types.forEach(function (type) {
-    // Initialize properties where hook functions are stored
-    hookData[type] = {};
-  }); // Add non-enumerable `__hooks` property to the object
+  var _iterator = _createForOfIteratorHelper(methods),
+      _step;
+
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var method = _step.value;
+      store.hooks[method] = [];
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
 
-  Object.defineProperty(obj, '__hooks', {
+  return store;
+};
+
+var setStore = function setStore(object, store) {
+  Object.defineProperty(object, '__hooks', {
     configurable: true,
-    value: hookData,
+    value: store,
     writable: true
   });
-  return function legacyHooks(allHooks) {
-    var _this = this;
+};
+
+var getStore = function getStore(object) {
+  return object.__hooks;
+};
+
+var createMap = function createMap(input, methods) {
+  var map = {};
+  Object.keys(input).forEach(function (type) {
+    if (!isType(type)) {
+      throw new Error("'".concat(type, "' is not a valid hook type"));
+    }
 
-    each(allHooks, function (current, type) {
-      if (!_this.__hooks[type]) {
-        throw new Error("'".concat(type, "' is not a valid hook type"));
+    var data = convertHookData(input[type]);
+    Object.keys(data).forEach(function (method) {
+      if (method !== 'all' && !methods.includes(method)) {
+        throw new Error("'".concat(method, "' is not a valid hook method"));
       }
+    });
+    map[type] = data;
+  });
+  return map;
+};
 
-      var hooks = convertHookData(current);
-      each(hooks, function (_value, method) {
-        if (method !== 'all' && methods.indexOf(method) === -1) {
-          throw new Error("'".concat(method, "' is not a valid hook method"));
-        }
-      });
-      methods.forEach(function (method) {
-        var _this$__hooks$type$me;
+var createAdapter = function createAdapter(type) {
+  var hooks = [];
+  var hook = wrappers[type](hooks);
+  var adapter = Object.assign(hook, {
+    hooks: hooks
+  });
+  return adapter;
+};
 
-        var currentHooks = [].concat(_toConsumableArray(hooks.all || []), _toConsumableArray(hooks[method] || []));
-        _this.__hooks[type][method] = _this.__hooks[type][method] || [];
+var updateStore = function updateStore(store, map) {
+  Object.keys(store.hooks).forEach(function (method) {
+    var adapted = false;
+    Object.keys(map).forEach(function (key) {
+      var _a;
 
-        if (type === 'before') {
-          currentHooks = currentHooks.map(fromBeforeHook);
-        }
+      var type = key;
+      var allHooks = map[type].all || [];
+      var methodHooks = map[type][method] || [];
 
-        if (type === 'after') {
-          currentHooks = currentHooks.map(fromAfterHook);
-        }
+      if (allHooks.length || methodHooks.length) {
+        var _adapter$hooks;
 
-        (_this$__hooks$type$me = _this.__hooks[type][method]).push.apply(_this$__hooks$type$me, _toConsumableArray(currentHooks));
-      });
+        var adapter = (_a = store[type])[method] || (_a[method] = (adapted = true, createAdapter(type)));
+
+        (_adapter$hooks = adapter.hooks).push.apply(_adapter$hooks, _toConsumableArray(allHooks).concat(_toConsumableArray(methodHooks)));
+      }
     });
+
+    if (adapted) {
+      store.hooks[method] = [store.error[method], store.before[method], store.after[method]].filter(function (hook) {
+        return hook;
+      });
+    }
+  });
+}; // Add `.hooks` functionality to an object
+
+
+function enableRegularHooks(object) {
+  var methods = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : service_1.defaultServiceMethods;
+  var store = createStore(methods);
+  setStore(object, store);
+  return function regularHooks(input) {
+    var store = getStore(this);
+    var map = createMap(input, methods);
+    updateStore(store, map);
     return this;
   };
 }
 
-exports.enableLegacyHooks = enableLegacyHooks;
+exports.enableRegularHooks = enableRegularHooks;
 
 /***/ }),
 
@@ -1847,7 +1929,7 @@ exports.defaultEventMap = {
   patch: 'patched',
   remove: 'removed'
 };
-exports.protectedMethods = Object.keys(Object.prototype).concat(Object.keys(dependencies_1.EventEmitter.prototype)).concat(['before', 'after', 'error', 'hooks', 'setup', 'publish']);
+exports.protectedMethods = Object.keys(Object.prototype).concat(Object.keys(dependencies_1.EventEmitter.prototype)).concat(['all', 'before', 'after', 'error', 'hooks', 'setup', 'publish']);
 
 function getHookMethods(service, options) {
   var methods = options.methods;