@strapi/utils 0.0.0-fd8e4c6bfa → 0.0.0-ffd0a215143bcafd0354d791533a57a084e53ffb

package/lib/async.d.ts

@@ -0,0 +1,12 @@
+export type MapAsync<T = any, R = any> = lodash.CurriedFunction3<
+  T[],
+  (element: T, index: number) => R | Promise<R>,
+  { concurrency?: number },
+  Promise<R[]>
+>;
+
+export type ForEachAsync<T = any, R = any> = (
+  array: T[],
+  func: (element: T, index: number) => R | Promise<R>,
+  options?: { concurrency?: number }
+) => Promise<R[]>;

package/lib/async.js

@@ -0,0 +1,34 @@
+'use strict';
+
+const pMap = require('p-map');
+const { curry } = require('lodash/fp');
+
+function pipeAsync(...methods) {
+  return async (data) => {
+    let res = data;
+
+    for (const method of methods) {
+      res = await method(res);
+    }
+
+    return res;
+  };
+}
+
+/**
+ * @type { import('./async').MapAsync }
+ */
+const mapAsync = curry(pMap);
+
+/**
+ * @type { import('./async').ForEachAsync }
+ */
+const forEachAsync = curry(async (array, func, options) => {
+  await mapAsync(array, func, options);
+});
+
+module.exports = {
+  mapAsync,
+  forEachAsync,
+  pipeAsync,
+};

package/lib/build-query.js

@@ -21,7 +21,7 @@ const getAssociationFromFieldKey = ({ model, field }) => {
   let association;
   let attribute;
 
-  for (let i = 0; i < fieldParts.length; i++) {
+  for (let i = 0; i < fieldParts.length; i += 1) {
     const part = fieldParts[i];
     attribute = part;
 

package/lib/content-types.js

@@ -104,7 +104,26 @@ const isPrivateAttribute = (model = {}, attributeName) => {
 };
 
 const isScalarAttribute = (attribute) => {
-  return !['media', 'component', 'relation', 'dynamiczone'].includes(attribute.type);
+  return !['media', 'component', 'relation', 'dynamiczone'].includes(attribute?.type);
+};
+const isMediaAttribute = (attribute) => attribute?.type === 'media';
+const isRelationalAttribute = (attribute) => attribute?.type === 'relation';
+const isComponentAttribute = (attribute) => ['component', 'dynamiczone'].includes(attribute?.type);
+
+const isDynamicZoneAttribute = (attribute) => attribute?.type === 'dynamiczone';
+const isMorphToRelationalAttribute = (attribute) => {
+  return isRelationalAttribute(attribute) && attribute?.relation?.startsWith?.('morphTo');
+};
+
+const getComponentAttributes = (schema) => {
+  return _.reduce(
+    schema.attributes,
+    (acc, attr, attrName) => {
+      if (isComponentAttribute(attr)) acc.push(attrName);
+      return acc;
+    },
+    []
+  );
 };
 
 const getScalarAttributes = (schema) => {
@@ -118,10 +137,6 @@ const getScalarAttributes = (schema) => {
   );
 };
 
-const isMediaAttribute = (attribute) => attribute.type === 'media';
-const isRelationalAttribute = (attribute) => attribute.type === 'relation';
-const isComponentAttribute = (attribute) => ['component', 'dynamiczone'].includes(attribute.type);
-
 /**
  * Checks if an attribute is of type `type`
  * @param {object} attribute
@@ -147,11 +162,14 @@ module.exports = {
   isMediaAttribute,
   isRelationalAttribute,
   isComponentAttribute,
+  isDynamicZoneAttribute,
+  isMorphToRelationalAttribute,
   isTypedAttribute,
   getPrivateAttributes,
   isPrivateAttribute,
   constants,
   getNonWritableAttributes,
+  getComponentAttributes,
   getScalarAttributes,
   getWritableAttributes,
   isWritableAttribute,

package/lib/convert-query-params.js

@@ -6,10 +6,28 @@
  * Converts the standard Strapi REST query params to a more usable format for querying
  * You can read more here: https://docs.strapi.io/developer-docs/latest/developer-resources/database-apis-reference/rest-api.html#filters
  */
-const { has, isEmpty, isObject, isPlainObject, cloneDeep, get, mergeAll } = require('lodash/fp');
+
+const {
+  isNil,
+  toNumber,
+  isInteger,
+  has,
+  isEmpty,
+  isObject,
+  isPlainObject,
+  cloneDeep,
+  get,
+  mergeAll,
+} = require('lodash/fp');
 const _ = require('lodash');
 const parseType = require('./parse-type');
 const contentTypesUtils = require('./content-types');
+const { PaginationError } = require('./errors');
+const {
+  isMediaAttribute,
+  isDynamicZoneAttribute,
+  isMorphToRelationalAttribute,
+} = require('./content-types');
 
 const { PUBLISHED_AT_ATTRIBUTE } = contentTypesUtils.constants;
 
@@ -37,6 +55,10 @@ const convertCountQueryParams = (countQuery) => {
   return parseType({ type: 'boolean', value: countQuery });
 };
 
+const convertOrderingQueryParams = (ordering) => {
+  return ordering;
+};
+
 /**
  * Sort query parser
  * @param {string} sortQuery - ex: id:asc,price:desc
@@ -117,6 +139,41 @@ const convertLimitQueryParams = (limitQuery) => {
   return limitAsANumber;
 };
 
+const convertPageQueryParams = (page) => {
+  const pageVal = toNumber(page);
+
+  if (!isInteger(pageVal) || pageVal <= 0) {
+    throw new PaginationError(
+      `Invalid 'page' parameter. Expected an integer > 0, received: ${page}`
+    );
+  }
+
+  return pageVal;
+};
+
+const convertPageSizeQueryParams = (pageSize, page) => {
+  const pageSizeVal = toNumber(pageSize);
+
+  if (!isInteger(pageSizeVal) || pageSizeVal <= 0) {
+    throw new PaginationError(
+      `Invalid 'pageSize' parameter. Expected an integer > 0, received: ${page}`
+    );
+  }
+
+  return pageSizeVal;
+};
+
+const validatePaginationParams = (page, pageSize, start, limit) => {
+  const isPagePagination = !isNil(page) || !isNil(pageSize);
+  const isOffsetPagination = !isNil(start) || !isNil(limit);
+
+  if (isPagePagination && isOffsetPagination) {
+    throw new PaginationError(
+      'Invalid pagination attributes. You cannot use page and offset pagination in the same query'
+    );
+  }
+};
+
 class InvalidPopulateError extends Error {
   constructor() {
     super();
@@ -169,12 +226,41 @@ const convertPopulateObject = (populate, schema) => {
       return acc;
     }
 
-    // FIXME: This is a temporary solution for dynamic zones that should be
-    // fixed when we'll implement a more accurate way to query them
+    // Allow adding an 'on' strategy to populate queries for polymorphic relations, media and dynamic zones
+    const isAllowedAttributeForFragmentPopulate =
+      isDynamicZoneAttribute(attribute) ||
+      isMediaAttribute(attribute) ||
+      isMorphToRelationalAttribute(attribute);
+
+    const hasFragmentPopulateDefined = typeof subPopulate === 'object' && 'on' in subPopulate;
+
+    if (isAllowedAttributeForFragmentPopulate && hasFragmentPopulateDefined) {
+      return {
+        ...acc,
+        [key]: {
+          on: Object.entries(subPopulate.on).reduce(
+            (acc, [type, typeSubPopulate]) => ({
+              ...acc,
+              [type]: convertNestedPopulate(typeSubPopulate, strapi.getModel(type)),
+            }),
+            {}
+          ),
+        },
+      };
+    }
+
+    // TODO: This is a query's populate fallback for DynamicZone and is kept for legacy purpose.
+    //       Removing it could break existing user queries but it should be removed in V5.
     if (attribute.type === 'dynamiczone') {
       const populates = attribute.components
         .map((uid) => strapi.getModel(uid))
-        .map((schema) => convertNestedPopulate(subPopulate, schema));
+        .map((schema) => convertNestedPopulate(subPopulate, schema))
+        .map((populate) => (populate === true ? {} : populate)) // cast boolean to empty object to avoid merging issues
+        .filter((populate) => populate !== false);
+
+      if (isEmpty(populates)) {
+        return acc;
+      }
 
       return {
         ...acc,
@@ -203,16 +289,22 @@ const convertPopulateObject = (populate, schema) => {
       return acc;
     }
 
+    const populateObject = convertNestedPopulate(subPopulate, targetSchema);
+
+    if (!populateObject) {
+      return acc;
+    }
+
     return {
       ...acc,
-      [key]: convertNestedPopulate(subPopulate, targetSchema),
+      [key]: populateObject,
     };
   }, {});
 };
 
 const convertNestedPopulate = (subPopulate, schema) => {
-  if (subPopulate === '*') {
-    return true;
+  if (_.isString(subPopulate)) {
+    return parseType({ type: 'boolean', value: subPopulate, forceCast: true });
   }
 
   if (_.isBoolean(subPopulate)) {
@@ -223,8 +315,8 @@ const convertNestedPopulate = (subPopulate, schema) => {
     throw new Error(`Invalid nested populate. Expected '*' or an object`);
   }
 
-  // TODO: We will need to consider a way to add limitation / pagination
-  const { sort, filters, fields, populate, count } = subPopulate;
+  const { sort, filters, fields, populate, count, ordering, page, pageSize, start, limit } =
+    subPopulate;
 
   const query = {};
 
@@ -248,6 +340,30 @@ const convertNestedPopulate = (subPopulate, schema) => {
     query.count = convertCountQueryParams(count);
   }
 
+  if (ordering) {
+    query.ordering = convertOrderingQueryParams(ordering);
+  }
+
+  validatePaginationParams(page, pageSize, start, limit);
+
+  if (!isNil(page)) {
+    query.page = convertPageQueryParams(page);
+  }
+
+  if (!isNil(pageSize)) {
+    query.pageSize = convertPageSizeQueryParams(pageSize, page);
+  }
+
+  if (!isNil(start)) {
+    query.offset = convertStartQueryParams(start);
+  }
+
+  if (!isNil(limit)) {
+    query.limit = convertLimitQueryParams(limit);
+  }
+
+  convertPublicationStateParams(schema, subPopulate, query);
+
   return query;
 };
 
@@ -377,6 +493,57 @@ const convertPublicationStateParams = (type, params = {}, query = {}) => {
   }
 };
 
+const transformParamsToQuery = (uid, params) => {
+  // NOTE: can be a CT, a Compo or nothing in the case of polymorphism (DZ & morph relations)
+  const schema = strapi.getModel(uid);
+
+  const query = {};
+
+  const { _q, sort, filters, fields, populate, page, pageSize, start, limit } = params;
+
+  if (!isNil(_q)) {
+    query._q = _q;
+  }
+
+  if (!isNil(sort)) {
+    query.orderBy = convertSortQueryParams(sort);
+  }
+
+  if (!isNil(filters)) {
+    query.where = convertFiltersQueryParams(filters, schema);
+  }
+
+  if (!isNil(fields)) {
+    query.select = convertFieldsQueryParams(fields);
+  }
+
+  if (!isNil(populate)) {
+    query.populate = convertPopulateQueryParams(populate, schema);
+  }
+
+  validatePaginationParams(page, pageSize, start, limit);
+
+  if (!isNil(page)) {
+    query.page = convertPageQueryParams(page);
+  }
+
+  if (!isNil(pageSize)) {
+    query.pageSize = convertPageSizeQueryParams(pageSize, page);
+  }
+
+  if (!isNil(start)) {
+    query.offset = convertStartQueryParams(start);
+  }
+
+  if (!isNil(limit)) {
+    query.limit = convertLimitQueryParams(limit);
+  }
+
+  convertPublicationStateParams(schema, params, query);
+
+  return query;
+};
+
 module.exports = {
   convertSortQueryParams,
   convertStartQueryParams,
@@ -385,4 +552,5 @@ module.exports = {
   convertFiltersQueryParams,
   convertFieldsQueryParams,
   convertPublicationStateParams,
+  transformParamsToQuery,
 };

package/lib/errors.js

@@ -55,19 +55,28 @@ class ForbiddenError extends ApplicationError {
   }
 }
 
-class PayloadTooLargeError extends ApplicationError {
+class UnauthorizedError extends ApplicationError {
   constructor(message, details) {
     super(message, details);
-    this.name = 'PayloadTooLargeError';
-    this.message = message || 'Entity too large';
+    this.name = 'UnauthorizedError';
+    this.message = message || 'Unauthorized';
   }
 }
 
-class UnauthorizedError extends ApplicationError {
+class RateLimitError extends ApplicationError {
   constructor(message, details) {
     super(message, details);
-    this.name = 'UnauthorizedError';
-    this.message = message || 'Unauthorized';
+    this.name = 'RateLimitError';
+    this.message = message || 'Too many requests, please try again later.';
+    this.details = details || {};
+  }
+}
+
+class PayloadTooLargeError extends ApplicationError {
+  constructor(message, details) {
+    super(message, details);
+    this.name = 'PayloadTooLargeError';
+    this.message = message || 'Entity too large';
   }
 }
 
@@ -88,7 +97,8 @@ module.exports = {
   PaginationError,
   NotFoundError,
   ForbiddenError,
-  PayloadTooLargeError,
   UnauthorizedError,
+  RateLimitError,
+  PayloadTooLargeError,
   PolicyError,
 };

package/lib/file.js

@@ -0,0 +1,60 @@
+'use strict';
+
+/**
+ * Utils file containing file treatment utils
+ */
+const { Writable } = require('stream');
+
+const kbytesToBytes = (kbytes) => kbytes * 1000;
+const bytesToKbytes = (bytes) => Math.round((bytes / 1000) * 100) / 100;
+const bytesToHumanReadable = (bytes) => {
+  const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB', 'PB'];
+  if (bytes === 0) return '0 Bytes';
+  const i = parseInt(Math.floor(Math.log(bytes) / Math.log(1000)), 10);
+  return `${Math.round(bytes / 1000 ** i, 2)} ${sizes[i]}`;
+};
+
+const streamToBuffer = (stream) =>
+  new Promise((resolve, reject) => {
+    const chunks = [];
+    stream.on('data', (chunk) => {
+      chunks.push(chunk);
+    });
+    stream.on('end', () => {
+      resolve(Buffer.concat(chunks));
+    });
+    stream.on('error', reject);
+  });
+
+const getStreamSize = (stream) =>
+  new Promise((resolve, reject) => {
+    let size = 0;
+    stream.on('data', (chunk) => {
+      size += Buffer.byteLength(chunk);
+    });
+    stream.on('close', () => resolve(size));
+    stream.on('error', reject);
+    stream.resume();
+  });
+
+/**
+ * Create a writeable Node.js stream that discards received data.
+ * Useful for testing, draining a stream of data, etc.
+ */
+function writableDiscardStream(options) {
+  return new Writable({
+    ...options,
+    write(chunk, encding, callback) {
+      setImmediate(callback);
+    },
+  });
+}
+
+module.exports = {
+  streamToBuffer,
+  bytesToHumanReadable,
+  bytesToKbytes,
+  kbytesToBytes,
+  getStreamSize,
+  writableDiscardStream,
+};

package/lib/hooks.js

@@ -2,17 +2,8 @@
 
 const { eq, remove, cloneDeep } = require('lodash/fp');
 
-/**
- * @typedef Hook
- * @property {Array<Function>} _handlers - A registry of handler used by the hook
- * @property {function(Function):Hook} register - Register a new handler into the hook's registry
- * @property {function(Function):Hook} delete- Delete the given handler from the hook's registry
- * @property {Function} call - Not implemented by default, can be replaced by any implementation.
- */
-
 /**
  * Create a default Strapi hook
- * @return {Hook}
  */
 const createHook = () => {
   const state = {
@@ -45,7 +36,6 @@ const createHook = () => {
 /**
  * Create an async series hook.
  * Upon execution, it will execute every handler in order with the same context
- * @return {Hook}
  */
 const createAsyncSeriesHook = () => ({
   ...createHook(),
@@ -60,7 +50,6 @@ const createAsyncSeriesHook = () => ({
 /**
  * Create an async series waterfall hook.
  * Upon execution, it will execute every handler in order and pass the return value of the last handler to the next one
- * @return {Hook}
  */
 const createAsyncSeriesWaterfallHook = () => ({
   ...createHook(),
@@ -79,7 +68,6 @@ const createAsyncSeriesWaterfallHook = () => ({
 /**
  * Create an async parallel hook.
  * Upon execution, it will execute every registered handler in band.
- * @return {Hook}
  */
 const createAsyncParallelHook = () => ({
   ...createHook(),
@@ -91,6 +79,24 @@ const createAsyncParallelHook = () => ({
   },
 });
 
+/**
+ * Create an async parallel hook.
+ * Upon execution, it will execute every registered handler in serie and return the first result found.
+ */
+const createAsyncBailHook = () => ({
+  ...createHook(),
+
+  async call(context) {
+    for (const handler of this.getHandlers()) {
+      const result = await handler(context);
+
+      if (result !== undefined) {
+        return result;
+      }
+    }
+  },
+});
+
 module.exports = {
   // Internal utils
   internals: {
@@ -100,4 +106,5 @@ module.exports = {
   createAsyncSeriesHook,
   createAsyncSeriesWaterfallHook,
   createAsyncParallelHook,
+  createAsyncBailHook,
 };

package/lib/import-default.js

@@ -0,0 +1,10 @@
+'use strict';
+
+const importDefault =
+  (this && this.importDefault) ||
+  function (modName) {
+    const mod = require(modName);
+    return mod && mod.__esModule ? mod.default : mod;
+  };
+
+module.exports = importDefault;

package/lib/index.js

@@ -24,7 +24,7 @@ const {
   joinBy,
   toKebabCase,
 } = require('./string-formatting');
-const { removeUndefined } = require('./object-formatting');
+const { removeUndefined, keysDeep } = require('./object-formatting');
 const { getConfigUrls, getAbsoluteAdminUrl, getAbsoluteServerUrl } = require('./config');
 const { generateTimestampCode } = require('./code-generator');
 const contentTypes = require('./content-types');
@@ -37,7 +37,11 @@ const providerFactory = require('./provider-factory');
 const pagination = require('./pagination');
 const sanitize = require('./sanitize');
 const traverseEntity = require('./traverse-entity');
-const pipeAsync = require('./pipe-async');
+const { pipeAsync, mapAsync, forEachAsync } = require('./async');
+const convertQueryParams = require('./convert-query-params');
+const importDefault = require('./import-default');
+const template = require('./template');
+const file = require('./file');
 
 module.exports = {
   yup,
@@ -59,11 +63,13 @@ module.exports = {
   getConfigUrls,
   escapeQuery,
   removeUndefined,
+  keysDeep,
   getAbsoluteAdminUrl,
   getAbsoluteServerUrl,
   generateTimestampCode,
   stringIncludes,
   stringEquals,
+  template,
   isKebabCase,
   isCamelCase,
   toKebabCase,
@@ -76,7 +82,12 @@ module.exports = {
   providerFactory,
   pagination,
   pipeAsync,
+  mapAsync,
+  forEachAsync,
   errors,
   validateYupSchema,
   validateYupSchemaSync,
+  convertQueryParams,
+  importDefault,
+  file,
 };

package/lib/object-formatting.js

@@ -4,6 +4,12 @@ const _ = require('lodash');
 
 const removeUndefined = (obj) => _.pickBy(obj, (value) => typeof value !== 'undefined');
 
+const keysDeep = (obj, path = []) =>
+  !_.isObject(obj)
+    ? path.join('.')
+    : _.reduce(obj, (acc, next, key) => _.concat(acc, keysDeep(next, [...path, key])), []);
+
 module.exports = {
   removeUndefined,
+  keysDeep,
 };

package/lib/print-value.js

@@ -11,6 +11,7 @@ const symbolToString = typeof Symbol !== 'undefined' ? Symbol.prototype.toString
 const SYMBOL_REGEXP = /^Symbol\((.*)\)(.*)$/;
 
 function printNumber(val) {
+  // eslint-disable-next-line eqeqeq
   if (val != +val) return 'NaN';
   const isNegativeZero = val === 0 && 1 / val < 0;
   return isNegativeZero ? '-0' : `${val}`;

package/lib/provider-factory.js

@@ -25,25 +25,9 @@ const createProviderHooksMap = () => ({
 });
 
 /**
- * A customizable item provider enhanced with register/delete hooks
- * @typedef {Object} Provider
- * @property hooks
- * @property register
- * @property delete
- * @property get
- * @property getWhere
- * @property values
- * @property keys
- * @property has
- * @property size
- * @property clear
- */
-
-/**
- * A {@link Provider} factory
+ * A Provider factory
  * @param {Object} [options] - The factory options
  * @param {boolean = true} options.throwOnDuplicates - Specify the wanted behaviour when encountering a duplicate key on register
- * @return {Provider}
  */
 const providerFactory = (options = {}) => {
   const { throwOnDuplicates = true } = options;

package/lib/relations.js

@@ -1,5 +1,7 @@
 'use strict';
 
+const { isRelationalAttribute } = require('./content-types');
+
 const MANY_RELATIONS = ['oneToMany', 'manyToMany'];
 
 const getRelationalFields = (contentType) => {
@@ -8,8 +10,21 @@ const getRelationalFields = (contentType) => {
   });
 };
 
+const isOneToAny = (attribute) =>
+  isRelationalAttribute(attribute) && ['oneToOne', 'oneToMany'].includes(attribute.relation);
+const isManyToAny = (attribute) =>
+  isRelationalAttribute(attribute) && ['manyToMany', 'manyToOne'].includes(attribute.relation);
+const isAnyToOne = (attribute) =>
+  isRelationalAttribute(attribute) && ['oneToOne', 'manyToOne'].includes(attribute.relation);
+const isAnyToMany = (attribute) =>
+  isRelationalAttribute(attribute) && ['oneToMany', 'manyToMany'].includes(attribute.relation);
+
 module.exports = {
   getRelationalFields,
+  isOneToAny,
+  isManyToAny,
+  isAnyToOne,
+  isAnyToMany,
   constants: {
     MANY_RELATIONS,
   },

package/lib/sanitize/index.js

@@ -4,7 +4,7 @@ const { isArray } = require('lodash/fp');
 
 const traverseEntity = require('../traverse-entity');
 const { getNonWritableAttributes } = require('../content-types');
-const pipeAsync = require('../pipe-async');
+const { pipeAsync } = require('../async');
 
 const visitors = require('./visitors');
 const sanitizers = require('./sanitizers');

package/lib/sanitize/sanitizers.js

@@ -2,7 +2,7 @@
 
 const { curry } = require('lodash/fp');
 
-const pipeAsync = require('../pipe-async');
+const { pipeAsync } = require('../async');
 const traverseEntity = require('../traverse-entity');
 
 const { removePassword, removePrivate } = require('./visitors');

package/lib/template.js

@@ -0,0 +1,28 @@
+'use strict';
+
+/**
+ * Create a strict interpolation RegExp based on the given variables' name
+ *
+ * @param {string[]} allowedVariableNames - The list of allowed variables
+ * @param {string} [flags] - The RegExp flags
+ */
+const createStrictInterpolationRegExp = (allowedVariableNames, flags) => {
+  const oneOfVariables = allowedVariableNames.join('|');
+
+  // 1. We need to match the delimiters: <%= ... %>
+  // 2. We accept any number of whitespaces characters before and/or after the variable name: \s* ... \s*
+  // 3. We only accept values from the variable list as interpolation variables' name: : (${oneOfVariables})
+  return new RegExp(`<%=\\s*(${oneOfVariables})\\s*%>`, flags);
+};
+
+/**
+ * Create a loose interpolation RegExp to match as many groups as possible
+ *
+ * @param {string} [flags] - The RegExp flags
+ */
+const createLooseInterpolationRegExp = (flags) => new RegExp(/<%=([\s\S]+?)%>/, flags);
+
+module.exports = {
+  createStrictInterpolationRegExp,
+  createLooseInterpolationRegExp,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strapi/utils",
-  "version": "0.0.0-fd8e4c6bfa",
+  "version": "0.0.0-ffd0a215143bcafd0354d791533a57a084e53ffb",
   "description": "Shared utilities for the Strapi packages",
   "keywords": [
     "strapi",
@@ -36,14 +36,15 @@
   },
   "dependencies": {
     "@sindresorhus/slugify": "1.1.0",
-    "date-fns": "2.29.2",
+    "date-fns": "2.29.3",
     "http-errors": "1.8.1",
     "lodash": "4.17.21",
+    "p-map": "4.0.0",
     "yup": "0.32.9"
   },
   "engines": {
-    "node": ">=14.19.1 <=16.x.x",
+    "node": ">=14.19.1 <=18.x.x",
     "npm": ">=6.0.0"
   },
-  "gitHead": "fd8e4c6bfa2fd687a3c62f8428e00f3b320c32c2"
+  "gitHead": "ffd0a215143bcafd0354d791533a57a084e53ffb"
 }

package/lib/pipe-async.js

@@ -1,13 +0,0 @@
-'use strict';
-
-module.exports =
-  (...methods) =>
-  async (data) => {
-    let res = data;
-
-    for (const method of methods) {
-      res = await method(res);
-    }
-
-    return res;
-  };