feathers-utils 2.0.0-9 → 2.1.0

package/dist/index.mjs

@@ -0,0 +1,938 @@
+import { Forbidden, GeneralError, BadRequest, MethodNotAllowed } from '@feathersjs/errors';
+import _merge from 'lodash/merge.js';
+import _isEmpty from 'lodash/isEmpty.js';
+import _get from 'lodash/get.js';
+import _has from 'lodash/has.js';
+import _set from 'lodash/set.js';
+import _uniqWith from 'lodash/uniqWith.js';
+import { deepEqual } from 'fast-equals';
+import { filterQuery as filterQuery$1 } from '@feathersjs/adapter-commons';
+import _isEqual from 'lodash/isEqual.js';
+import { _ } from '@feathersjs/commons';
+import { checkContext } from 'feathers-hooks-common';
+import _debounce from 'lodash/debounce.js';
+import _isObject from 'lodash/isObject.js';
+
+function mergeArrays(targetArr, sourceArr, handle, prependKey, actionOnEmptyIntersect) {
+  if (!sourceArr && !targetArr) {
+    return;
+  }
+  if (handle === "target") {
+    return targetArr;
+  } else if (handle === "source") {
+    return sourceArr;
+  } else if (handle === "combine") {
+    if (!sourceArr || !Array.isArray(sourceArr)) {
+      return targetArr;
+    }
+    if (!targetArr || !Array.isArray(targetArr)) {
+      return sourceArr;
+    }
+    const arr = targetArr.concat(sourceArr);
+    return [...new Set(arr)];
+  } else if (handle === "intersect" || handle === "intersectOrFull") {
+    const targetIsArray = !targetArr || !Array.isArray(targetArr);
+    const sourceIsArray = !sourceArr || !Array.isArray(sourceArr);
+    if ((targetIsArray || sourceIsArray) && handle === "intersect") {
+      if (actionOnEmptyIntersect) {
+        actionOnEmptyIntersect(
+          targetArr,
+          sourceArr,
+          prependKey || []
+        );
+      }
+      return;
+    }
+    if (handle === "intersectOrFull") {
+      const val = !targetIsArray ? targetArr : sourceArr;
+      return val;
+    }
+    return targetArr.filter((val) => sourceArr.includes(val));
+  }
+  return void 0;
+}
+
+const hasOwnProperty = (obj, ...keys) => {
+  return keys.some((x) => Object.prototype.hasOwnProperty.call(obj, x));
+};
+
+function handleArray(target, source, key, options) {
+  const targetVal = _get(target, key);
+  const sourceVal = _get(source, key);
+  if (!sourceVal && !targetVal) {
+    return;
+  }
+  const handle = _get(
+    options,
+    ["handle", ...key],
+    options.defaultHandle
+  );
+  const arr = mergeArrays(
+    targetVal,
+    sourceVal,
+    handle,
+    key,
+    options.actionOnEmptyIntersect
+  );
+  _set(target, key, arr);
+}
+function handleCircular(target, source, prependKey, options) {
+  if (target?.$or) {
+    target.$or = cleanOr(target.$or);
+    if (!target.$or) {
+      delete target.$or;
+    }
+  }
+  if (source?.$or) {
+    source.$or = cleanOr(source.$or);
+    if (!source.$or) {
+      delete source.$or;
+    }
+  }
+  if (target?.$and) {
+    target.$and = cleanAnd(target.$and);
+    if (!target.$and) {
+      delete target.$and;
+    }
+  }
+  if (source?.$and) {
+    source.$and = cleanAnd(source.$and);
+    if (!source.$and) {
+      delete source.$and;
+    }
+  }
+  if (!_has(source, prependKey)) {
+    return;
+  }
+  if (!_has(target, prependKey)) {
+    _set(target, prependKey, _get(source, prependKey));
+    return;
+  }
+  const { defaultHandle, actionOnEmptyIntersect } = options;
+  if (defaultHandle === "target") {
+    return;
+  }
+  const getTargetVal = () => {
+    return prependKey.length > 0 ? _get(target, prependKey) : target;
+  };
+  const getSourceVal = () => {
+    return prependKey.length > 0 ? _get(source, prependKey) : source;
+  };
+  const targetVal = getTargetVal();
+  const sourceVal = getSourceVal();
+  if (deepEqual(targetVal, sourceVal)) {
+    return;
+  }
+  if (defaultHandle === "source") {
+    _set(target, prependKey, sourceVal);
+    return;
+  }
+  if (targetVal === null || sourceVal === null) {
+    _set(target, prependKey, sourceVal);
+    return;
+  }
+  const typeOfTargetVal = typeof targetVal;
+  if (["boolean"].includes(typeOfTargetVal)) {
+    if (defaultHandle === "intersect") {
+      actionOnEmptyIntersect(target, source, prependKey);
+    }
+    _set(target, prependKey, sourceVal);
+    return;
+  }
+  const typeOfSourceVal = typeof sourceVal;
+  const isTargetSimple = ["string", "number"].includes(typeOfTargetVal);
+  const isSourceSimple = ["string", "number"].includes(typeOfSourceVal);
+  if (isTargetSimple || isSourceSimple) {
+    if (isTargetSimple && isSourceSimple) {
+      if (defaultHandle === "combine") {
+        _set(target, prependKey, { $in: [.../* @__PURE__ */ new Set([targetVal, sourceVal])] });
+        return;
+      } else if (defaultHandle === "intersect") {
+        actionOnEmptyIntersect(target, source, prependKey);
+      } else {
+        throw new Error("should not reach here");
+      }
+    } else if (hasOwnProperty(targetVal, "$in") || hasOwnProperty(sourceVal, "$in")) {
+      const targetHasIn = hasOwnProperty(targetVal, "$in");
+      const $in = targetHasIn ? targetVal["$in"] : sourceVal["$in"];
+      const otherVal = isTargetSimple ? targetVal : sourceVal;
+      if ($in.length === 1 && deepEqual($in[0], otherVal)) {
+        _set(target, prependKey, otherVal);
+        return;
+      } else if (defaultHandle === "combine") {
+        if (!$in.some((x) => deepEqual(x, otherVal))) {
+          $in.push(otherVal);
+        }
+        _set(target, `${prependKey}.$in`, $in);
+        return;
+      } else if (defaultHandle === "intersect") {
+        if ($in.some((x) => deepEqual(x, otherVal))) {
+          _set(target, prependKey, otherVal);
+        } else {
+          actionOnEmptyIntersect(target, source, prependKey);
+        }
+        return;
+      }
+      return;
+    }
+  }
+  const isTargetArray = Array.isArray(targetVal);
+  const isSourceArray = Array.isArray(sourceVal);
+  if (isTargetArray && isSourceArray) {
+    const key = prependKey[prependKey.length - 1];
+    if (key === "$or") {
+      if (defaultHandle === "combine") {
+        const newVals = sourceVal.filter(
+          (x) => !targetVal.some((y) => deepEqual(x, y))
+        );
+        targetVal.push(...newVals);
+      } else if (defaultHandle === "intersect") {
+        const targetParent = getParentProp(target, prependKey);
+        const sourceParent = getParentProp(source, prependKey);
+        targetParent.$and = targetParent.$and || [];
+        targetParent.$and.push({ $or: targetVal }, { $or: sourceVal });
+        targetParent.$and = cleanAnd(targetParent.$and);
+        if (!targetParent.$and) {
+          delete targetParent.$and;
+        }
+        delete targetParent.$or;
+        delete sourceParent.$or;
+        handleCircular(target, source, [...prependKey, "$and"], options);
+        return;
+      }
+      return;
+    } else if (key === "$and") {
+      if (defaultHandle === "combine") {
+        const targetParent = getParentProp(target, prependKey);
+        const sourceParent = getParentProp(source, prependKey);
+        targetParent.$or = targetParent.$or || [];
+        targetParent.$or.push({ $and: targetVal }, { $and: sourceVal });
+        targetParent.$or = cleanOr(targetParent.$or);
+        if (!targetParent.$or) {
+          delete targetParent.$or;
+        }
+        delete targetParent.$and;
+        delete sourceParent.$and;
+        handleCircular(target, source, [...prependKey, "$or"], options);
+        return;
+      } else if (defaultHandle === "intersect") {
+        const newVals = sourceVal.filter(
+          (x) => !targetVal.some((y) => deepEqual(x, y))
+        );
+        targetVal.push(...newVals);
+        return;
+      }
+    } else if (key === "$in") {
+      if (defaultHandle === "combine") {
+        let $in = targetVal.concat(sourceVal);
+        $in = [...new Set($in)];
+        _set(target, prependKey, $in);
+        return;
+      } else if (defaultHandle === "intersect") {
+        const $in = targetVal.filter(
+          (x) => sourceVal.some((y) => deepEqual(x, y))
+        );
+        if ($in.length === 0) {
+          actionOnEmptyIntersect(target, source, prependKey);
+        } else if ($in.length === 1) {
+          _set(target, prependKey.slice(0, -1), $in[0]);
+          return;
+        } else {
+          _set(target, prependKey, $in);
+        }
+      }
+      return;
+    }
+    _set(target, prependKey, sourceVal);
+    return;
+  }
+  if (typeOfTargetVal !== "object" || typeOfSourceVal !== "object") {
+    _set(target, prependKey, sourceVal);
+    return;
+  }
+  const sourceKeys = Object.keys(sourceVal);
+  for (let i = 0, n = sourceKeys.length; i < n; i++) {
+    const key = sourceKeys[i];
+    handleCircular(target, source, [...prependKey, key], options);
+  }
+}
+function makeDefaultOptions$1(options) {
+  options ?? (options = {});
+  options.defaultHandle ?? (options.defaultHandle = "combine");
+  options.useLogicalConjunction ?? (options.useLogicalConjunction = false);
+  options.actionOnEmptyIntersect ?? (options.actionOnEmptyIntersect = () => {
+    throw new Forbidden("You're not allowed to make this request");
+  });
+  options.handle = options.handle || {};
+  if (options.defaultHandle === "intersect") {
+    options.handle.$select = options.handle.$select || "intersectOrFull";
+  }
+  return options;
+}
+function moveProperty(from, to, ...keys) {
+  keys.forEach((key) => {
+    if (!hasOwnProperty(from, key)) {
+      return;
+    }
+    to[key] = from[key];
+    delete from[key];
+  });
+}
+function getParentProp(target, path) {
+  if (path.length <= 1) {
+    return target;
+  }
+  const pathOneUp = path.slice(0, -1);
+  return _get(target, pathOneUp);
+}
+function cleanOr(target) {
+  if (!target || !Array.isArray(target) || target.length <= 0) {
+    return target;
+  }
+  if (target.some((x) => _isEmpty(x))) {
+    return void 0;
+  } else {
+    return arrayWithoutDuplicates(target);
+  }
+}
+function cleanAnd(target) {
+  if (!target || !Array.isArray(target) || target.length <= 0) {
+    return target;
+  }
+  if (target.every((x) => _isEmpty(x))) {
+    return void 0;
+  } else {
+    target = target.filter((x) => !_isEmpty(x));
+    return arrayWithoutDuplicates(target);
+  }
+}
+function arrayWithoutDuplicates(target) {
+  if (!target || !Array.isArray(target)) {
+    return target;
+  }
+  return _uniqWith(target, deepEqual);
+}
+function isQueryMoreExplicitThanQuery(target, source) {
+  if (!target || !source) {
+    return;
+  }
+  const targetKeys = Object.keys(target);
+  const sourceKeys = Object.keys(source);
+  if (!sourceKeys.length) {
+    return target;
+  }
+  if (!targetKeys.length) {
+    return source;
+  }
+  if (targetKeys.every((key) => deepEqual(target[key], source[key]))) {
+    return source;
+  }
+  if (sourceKeys.every((key) => deepEqual(target[key], source[key]))) {
+    return target;
+  }
+  return;
+}
+function areQueriesOverlapping(target, source) {
+  if (!target || !source) {
+    return false;
+  }
+  const targetKeys = Object.keys(target);
+  const sourceKeys = Object.keys(source);
+  if (!sourceKeys.length || !targetKeys.length) {
+    return false;
+  }
+  if (targetKeys.some((x) => sourceKeys.includes(x)) || sourceKeys.some((x) => targetKeys.includes(x))) {
+    return true;
+  }
+  return false;
+}
+
+function filterQuery(query, _options) {
+  query = query || {};
+  _options = _options || {};
+  const { service, ...options } = _options;
+  if (service) {
+    const operators = options.operators ? options.operators : service.options?.operators;
+    const filters = options.filters ? options.filters : service.options?.filters;
+    const optionsForFilterQuery = {};
+    if (operators) {
+      optionsForFilterQuery.operators = operators;
+    }
+    if (filters) {
+      optionsForFilterQuery.filters = filters;
+    }
+    if (service && "filterQuery" in service && typeof service.filterQuery === "function") {
+      return service.filterQuery({ query }, optionsForFilterQuery);
+    } else {
+      return filterQuery$1(query, optionsForFilterQuery);
+    }
+  }
+  return filterQuery$1(query, options);
+}
+
+function mergeQuery(target, source, _options) {
+  const options = makeDefaultOptions$1(_options);
+  const { filters: targetFilters, query: targetQuery } = filterQuery(target, {
+    operators: options.operators,
+    filters: options.filters,
+    service: options.service
+  });
+  moveProperty(targetFilters, targetQuery, "$or", "$and");
+  if ("$limit" in target) {
+    targetFilters.$limit = target.$limit;
+  }
+  let {
+    // eslint-disable-next-line prefer-const
+    filters: sourceFilters,
+    query: sourceQuery
+  } = filterQuery(source, {
+    operators: options.operators,
+    filters: options.filters,
+    service: options.service
+  });
+  moveProperty(sourceFilters, sourceQuery, "$or", "$and");
+  if (source.$limit) {
+    sourceFilters.$limit = source.$limit;
+  }
+  if (target && !hasOwnProperty(target, "$limit") && hasOwnProperty(targetFilters, "$limit")) {
+    delete targetFilters.$limit;
+  }
+  if (source && !hasOwnProperty(source, "$limit") && hasOwnProperty(sourceFilters, "$limit")) {
+    delete sourceFilters.$limit;
+  }
+  handleArray(targetFilters, sourceFilters, ["$select"], options);
+  delete sourceFilters["$select"];
+  _merge(targetFilters, sourceFilters);
+  const subsetQuery = isQueryMoreExplicitThanQuery(targetQuery, sourceQuery);
+  if (options.defaultHandle === "intersect" && !!subsetQuery && !hasOwnProperty(targetQuery, "$or", "$and") && !hasOwnProperty(sourceQuery, "$or", "$and")) {
+    return {
+      ...targetFilters,
+      ...subsetQuery
+    };
+  }
+  if (options.defaultHandle === "intersect" && !areQueriesOverlapping(targetQuery, sourceQuery) && !hasOwnProperty(targetQuery, "$or", "$and") && !hasOwnProperty(sourceQuery, "$or", "$and")) {
+    return {
+      ...targetFilters,
+      ...targetQuery,
+      ...sourceQuery
+    };
+  }
+  if (options.useLogicalConjunction && (options.defaultHandle === "combine" || options.defaultHandle === "intersect") && !_isEmpty(targetQuery)) {
+    const logicalOp = options.defaultHandle === "combine" ? "$or" : "$and";
+    if (hasOwnProperty(sourceQuery, logicalOp)) {
+      const andOr = sourceQuery[logicalOp];
+      delete sourceQuery[logicalOp];
+      andOr.push(sourceQuery);
+      sourceQuery = { [logicalOp]: andOr };
+    } else {
+      sourceQuery = { [logicalOp]: [sourceQuery] };
+    }
+  }
+  const keys = Object.keys(sourceQuery);
+  for (let i = 0, n = keys.length; i < n; i++) {
+    const key = keys[i];
+    handleCircular(targetQuery, sourceQuery, [key], options);
+  }
+  return {
+    ...targetFilters,
+    ...targetQuery
+  };
+}
+
+const getItemsIsArray = (context, options) => {
+  const {
+    from = "automatic"
+  } = options || {};
+  let itemOrItems;
+  if (from === "automatic") {
+    itemOrItems = context.type === "before" ? context.data : context.result;
+    itemOrItems = itemOrItems && context.method === "find" ? itemOrItems.data || itemOrItems : itemOrItems;
+  } else if (from === "data") {
+    itemOrItems = context.data;
+  } else if (from === "result") {
+    itemOrItems = context.result;
+  }
+  const isArray = Array.isArray(itemOrItems);
+  return {
+    items: isArray ? itemOrItems : itemOrItems != null ? [itemOrItems] : [],
+    isArray
+  };
+};
+
+const getPaginate = (context) => {
+  if (hasOwnProperty(context.params, "paginate")) {
+    return context.params.paginate || void 0;
+  }
+  if (context.params.paginate === false) {
+    return void 0;
+  }
+  let options = context.service?.options || {};
+  options = {
+    ...options,
+    ...context.params.adapter
+  };
+  return options.paginate || void 0;
+};
+
+const isMulti = (context) => {
+  const { method } = context;
+  if (method === "find") {
+    return true;
+  } else if (["patch", "remove"].includes(method)) {
+    return context.id == null;
+  } else if (method === "create") {
+    const items = context.type === "before" ? context.data : context.result;
+    return Array.isArray(items);
+  } else if (["get", "update"].includes(method)) {
+    return false;
+  }
+  return false;
+};
+
+const isPaginated = (context) => {
+  if (context.params.paginate === false || context.method !== "find") {
+    return false;
+  }
+  const paginate = getPaginate(context);
+  return !!paginate;
+};
+
+const pushSet = (obj, path, val, options) => {
+  options = options || {};
+  let arr = _get(obj, path);
+  if (!arr || !Array.isArray(arr)) {
+    arr = [val];
+    _set(obj, path, arr);
+    return arr;
+  } else {
+    if (options.unique && arr.some((x) => _isEqual(x, val))) {
+      return arr;
+    }
+    arr.push(val);
+    return arr;
+  }
+};
+
+function markHookForSkip(hookName, type, context) {
+  context = context || {};
+  const params = context.params || {};
+  const types = Array.isArray(type) ? type : [type];
+  types.forEach((t) => {
+    const combinedName = t === "all" ? hookName : `${type}:${hookName}`;
+    pushSet(params, ["skipHooks"], combinedName, { unique: true });
+  });
+  context.params = params;
+  return context;
+}
+
+const setResultEmpty = (context) => {
+  if (context.result) {
+    return context;
+  }
+  const multi = isMulti(context);
+  if (multi) {
+    if (context.method === "find" && isPaginated(context)) {
+      context.result = {
+        total: 0,
+        skip: 0,
+        limit: 0,
+        data: []
+      };
+    } else {
+      context.result = [];
+    }
+  } else {
+    context.result = null;
+  }
+  return context;
+};
+
+const shouldSkip = (hookName, context, options) => {
+  if (!context.params || !context.params.skipHooks || options?.notSkippable) {
+    return false;
+  }
+  const { skipHooks } = context.params;
+  if (!Array.isArray(skipHooks)) {
+    throw new GeneralError("The `skipHooks` param must be an Array of Strings");
+  }
+  const { type } = context;
+  if (skipHooks.includes(hookName)) {
+    return true;
+  } else if (skipHooks.includes("all")) {
+    return true;
+  } else if (skipHooks.includes(type)) {
+    return true;
+  } else if (skipHooks.includes(`${type}:${hookName}`)) {
+    return true;
+  }
+  return false;
+};
+
+const isPlainObject = (value) => _.isObject(value) && value.constructor === {}.constructor;
+const validateQueryProperty = (query, operators = []) => {
+  if (!isPlainObject(query)) {
+    return query;
+  }
+  for (const key of Object.keys(query)) {
+    if (key.startsWith("$") && !operators.includes(key)) {
+      throw new BadRequest(`Invalid query parameter ${key}`, query);
+    }
+    const value = query[key];
+    if (isPlainObject(value)) {
+      query[key] = validateQueryProperty(value, operators);
+    }
+  }
+  return {
+    ...query
+  };
+};
+
+function checkMulti() {
+  return (context) => {
+    if (shouldSkip("checkMulti", context)) {
+      return context;
+    }
+    const { service, method } = context;
+    if (!service.allowsMulti || !isMulti(context) || method === "find") {
+      return context;
+    }
+    if (!service.allowsMulti(method)) {
+      throw new MethodNotAllowed(`Can not ${method} multiple entries`);
+    }
+    return context;
+  };
+}
+
+function createRelated({
+  service,
+  multi = true,
+  data,
+  createItemsInDataArraySeparately = true
+}) {
+  if (!service || !data) {
+    throw "initialize hook 'createRelated' completely!";
+  }
+  return async (context) => {
+    if (shouldSkip("createRelated", context)) {
+      return context;
+    }
+    checkContext(context, "after", void 0, "createRelated");
+    const { items } = getItemsIsArray(context);
+    let dataToCreate = (await Promise.all(items.map(async (item) => data(item, context)))).filter((x) => !!x);
+    if (createItemsInDataArraySeparately) {
+      dataToCreate = dataToCreate.flat();
+    }
+    if (!dataToCreate || dataToCreate.length <= 0) {
+      return context;
+    }
+    if (multi) {
+      await context.app.service(service).create(dataToCreate);
+    } else {
+      await Promise.all(
+        dataToCreate.map(
+          async (item) => context.app.service(service).create(item)
+        )
+      );
+    }
+    return context;
+  };
+}
+
+const forEach = (actionPerItem, _options) => {
+  const options = {
+    wait: "parallel",
+    items: "automatic",
+    ..._options
+  };
+  return async (context) => {
+    if (shouldSkip("runForItems", context)) {
+      return context;
+    }
+    const { items } = getItemsIsArray(context, { from: options.items });
+    const promises = [];
+    for (const item of items) {
+      const promise = actionPerItem(item, context);
+      if (options.wait === "sequential") {
+        await promise;
+      } else {
+        promises.push(promise);
+      }
+    }
+    if (options.wait === "parallel") {
+      await Promise.all(promises);
+    }
+    return context;
+  };
+};
+
+function onDelete(service, {
+  keyThere,
+  keyHere = "id",
+  onDelete: onDelete2 = "cascade",
+  blocking = true
+}) {
+  if (!service || !keyThere) {
+    throw "initialize hook 'removeRelated' completely!";
+  }
+  if (!["cascade", "set null"].includes(onDelete2)) {
+    throw "onDelete must be 'cascade' or 'set null'";
+  }
+  return async (context) => {
+    if (shouldSkip("onDelete", context)) {
+      return context;
+    }
+    checkContext(context, "after", "remove", "onDelete");
+    const { items } = getItemsIsArray(context);
+    let ids = items.map((x) => x[keyHere]).filter((x) => !!x);
+    ids = [...new Set(ids)];
+    if (!ids || ids.length <= 0) {
+      return context;
+    }
+    const params = {
+      query: {
+        [keyThere]: {
+          $in: ids
+        }
+      },
+      paginate: false
+    };
+    let promise;
+    if (onDelete2 === "cascade") {
+      promise = context.app.service(service).remove(null, params);
+    } else if (onDelete2 === "set null") {
+      const data = { [keyThere]: null };
+      promise = context.app.service(service).patch(null, data, params);
+    }
+    if (blocking) {
+      await promise;
+    }
+    return context;
+  };
+}
+
+const parseFields = (type, options) => (context) => {
+  const { items } = getItemsIsArray(context);
+  items.forEach((item) => {
+    options.fields.forEach((field) => {
+      if (!(field in item)) {
+        return;
+      }
+      if (type === "date") {
+        item[field] = new Date(item[field]);
+      } else if (type === "number") {
+        item[field] = Number(item[field]);
+      }
+    });
+  });
+  return context;
+};
+
+function removeRelated({
+  service,
+  keyThere,
+  keyHere = "id",
+  blocking = true
+}) {
+  if (!service || !keyThere) {
+    throw "initialize hook 'removeRelated' completely!";
+  }
+  return async (context) => {
+    if (shouldSkip("removeRelated", context)) {
+      return context;
+    }
+    checkContext(context, "after", "remove", "removeRelated");
+    const { items } = getItemsIsArray(context);
+    let ids = items.map((x) => x[keyHere]).filter((x) => !!x);
+    ids = [...new Set(ids)];
+    if (!ids || ids.length <= 0) {
+      return context;
+    }
+    const promise = context.app.service(service).remove(null, {
+      query: {
+        [keyThere]: {
+          $in: ids
+        }
+      },
+      paginate: false
+    });
+    if (blocking) {
+      await promise;
+    }
+    return context;
+  };
+}
+
+const makeOptions = (options) => {
+  options = options || {};
+  return {
+    wait: true,
+    ...options
+  };
+};
+const runPerItem = (actionPerItem, _options) => {
+  const options = makeOptions(_options);
+  return async (context) => {
+    if (shouldSkip("runForItems", context)) {
+      return context;
+    }
+    const { items } = getItemsIsArray(context);
+    const promises = items.map(async (item) => {
+      await actionPerItem(item, context);
+    });
+    if (options.wait) {
+      await Promise.all(promises);
+    }
+    return context;
+  };
+};
+
+const defaultOptions = {
+  allowUndefined: false,
+  overwrite: true
+};
+function setData(from, to, _options) {
+  const options = {
+    ...defaultOptions,
+    ..._options
+  };
+  return (context) => {
+    if (shouldSkip("setData", context)) {
+      return context;
+    }
+    const { items } = getItemsIsArray(context);
+    if (!_has(context, from)) {
+      if (!context.params?.provider || options.allowUndefined === true) {
+        return context;
+      }
+      if (!options.overwrite && items.every((item) => _has(item, to))) {
+        return context;
+      }
+      throw new Forbidden(`Expected field ${from.toString()} not available`);
+    }
+    const val = _get(context, from);
+    items.forEach((item) => {
+      let overwrite;
+      if (typeof options.overwrite === "function") {
+        overwrite = options.overwrite(item, context);
+      } else {
+        overwrite = options.overwrite;
+      }
+      if (!overwrite && _has(item, to)) {
+        return;
+      }
+      _set(item, to, val);
+    });
+    return context;
+  };
+}
+
+const makeDefaultOptions = () => {
+  return {
+    leading: false,
+    maxWait: void 0,
+    trailing: true,
+    wait: 100
+  };
+};
+class DebouncedStore {
+  constructor(app, options) {
+    this._app = app;
+    this._options = Object.assign(makeDefaultOptions(), options);
+    this._queueById = {};
+    this._isRunningById = {};
+    this.add = this.debounceById(this.unbounced, this._options.wait, {
+      leading: this._options.leading,
+      maxWait: this._options.maxWait,
+      trailing: this._options.trailing
+    });
+  }
+  async unbounced(id, action) {
+    if (this._queueById[id] === void 0) {
+      return;
+    }
+    delete this._queueById[id];
+    this._isRunningById[id] = true;
+    await action(this._app);
+    delete this._isRunningById[id];
+  }
+  debounceById(func, wait, options) {
+    return (id, action) => {
+      if (typeof this._queueById[id] === "function") {
+        return this._queueById[id](id, action);
+      }
+      this._queueById[id] = _debounce(
+        (id2, action2) => {
+          this.unbounced(id2, action2);
+        },
+        wait,
+        { ...options, leading: false }
+      );
+      return this._queueById[id](id, action);
+    };
+  }
+  cancel(id) {
+    delete this._queueById[id];
+  }
+}
+
+function debounceMixin(options) {
+  return (app) => {
+    options = options || {};
+    const defaultOptions = Object.assign(
+      makeDefaultOptions(),
+      options?.default
+    );
+    app.mixins.push((service, path) => {
+      if (options?.blacklist && options.blacklist.includes(path))
+        return;
+      if (service.debouncedStore) {
+        console.warn(
+          `[feathers-utils] service: '${path}' already has a property 'debouncedStore'. Mixin will skip creating a new debouncedStore`
+        );
+        return;
+      }
+      const serviceOptions = Object.assign({}, defaultOptions, options?.[path]);
+      service.debouncedStore = new DebouncedStore(
+        app,
+        serviceOptions
+      );
+    });
+  };
+}
+
+const filterQueryArray = (key) => (arr, { operators }) => {
+  if (arr && !Array.isArray(arr)) {
+    throw new Error(
+      `Invalid query parameter '${key}'. It has to be an array`
+    );
+  }
+  if (Array.isArray(arr)) {
+    return arr.map((current) => validateQueryProperty(current, operators));
+  }
+  return arr;
+};
+const filterArray = (...keys) => {
+  const result = {};
+  for (const key of keys) {
+    result[key] = filterQueryArray(key);
+  }
+  return result;
+};
+
+const filterQueryObject = (key) => (obj, { operators }) => {
+  if (obj && !_isObject(obj)) {
+    throw new Error(
+      `Invalid query parameter: '${key}'. It has to be an object`
+    );
+  }
+  return validateQueryProperty(obj, operators);
+};
+const filterObject = (...keys) => {
+  const result = {};
+  for (const key of keys) {
+    result[key] = filterQueryObject(key);
+  }
+  return result;
+};
+
+export { DebouncedStore, checkMulti, createRelated, debounceMixin, filterArray, filterObject, filterQuery, forEach, getItemsIsArray, getPaginate, isMulti, isPaginated, makeDefaultOptions, markHookForSkip, mergeArrays, mergeQuery, onDelete, parseFields, pushSet, removeRelated, runPerItem, setData, setResultEmpty, shouldSkip, validateQueryProperty };