@strapi/utils 4.6.0 → 4.6.2

package/lib/async.d.ts

@@ -0,0 +1,21 @@
+import { CurriedFunction3 } from 'lodash';
+
+export type MapAsync<T = any, R = any> = 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[]>;
+
+export type ReduceAsync<T = any, V = T, R = V> = CurriedFunction3<
+  T[],
+  (accumulator: V | R, current: Awaited<T>, index: number) => R | Promise<R>,
+  V,
+  Promise<R>
+>;

package/lib/async.js

@@ -0,0 +1,46 @@
+'use strict';
+
+const pMap = require('p-map');
+const { curry, curryN } = 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').ReduceAsync }
+ */
+const reduceAsync = curryN(2, async (mixedArray, iteratee, initialValue) => {
+  let acc = initialValue;
+  for (let i = 0; i < mixedArray.length; i += 1) {
+    acc = await iteratee(acc, await mixedArray[i], i);
+  }
+  return acc;
+});
+
+/**
+ * @type { import('./async').ForEachAsync }
+ */
+const forEachAsync = curry(async (array, func, options) => {
+  await mapAsync(array, func, options);
+});
+
+module.exports = {
+  mapAsync,
+  reduceAsync,
+  forEachAsync,
+  pipeAsync,
+};

package/lib/convert-query-params.js

@@ -139,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();
@@ -280,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, ordering } = subPopulate;
+  const { sort, filters, fields, populate, count, ordering, page, pageSize, start, limit } =
+    subPopulate;
 
   const query = {};
 
@@ -309,6 +344,26 @@ const convertNestedPopulate = (subPopulate, schema) => {
     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;
 };
 
@@ -466,37 +521,14 @@ const transformParamsToQuery = (uid, params) => {
     query.populate = convertPopulateQueryParams(populate, schema);
   }
 
-  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'
-    );
-  }
+  validatePaginationParams(page, pageSize, start, limit);
 
   if (!isNil(page)) {
-    const pageVal = toNumber(page);
-
-    if (!isInteger(pageVal) || pageVal <= 0) {
-      throw new PaginationError(
-        `Invalid 'page' parameter. Expected an integer > 0, received: ${page}`
-      );
-    }
-
-    query.page = pageVal;
+    query.page = convertPageQueryParams(page);
   }
 
   if (!isNil(pageSize)) {
-    const pageSizeVal = toNumber(pageSize);
-
-    if (!isInteger(pageSizeVal) || pageSizeVal <= 0) {
-      throw new PaginationError(
-        `Invalid 'pageSize' parameter. Expected an integer > 0, received: ${page}`
-      );
-    }
-
-    query.pageSize = pageSizeVal;
+    query.pageSize = convertPageSizeQueryParams(pageSize, page);
   }
 
   if (!isNil(start)) {

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/index.js

@@ -37,10 +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, reduceAsync, 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,
@@ -81,9 +82,13 @@ module.exports = {
   providerFactory,
   pagination,
   pipeAsync,
+  mapAsync,
+  reduceAsync,
+  forEachAsync,
   errors,
   validateYupSchema,
   validateYupSchemaSync,
   convertQueryParams,
   importDefault,
+  file,
 };

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strapi/utils",
-  "version": "4.6.0",
+  "version": "4.6.2",
   "description": "Shared utilities for the Strapi packages",
   "keywords": [
     "strapi",
@@ -39,11 +39,12 @@
     "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 <=18.x.x",
     "npm": ">=6.0.0"
   },
-  "gitHead": "a9e55435c489f3379d88565bf3f729deb29bfb45"
+  "gitHead": "bae505f44c3a779905f6b8dbc0c497e24d9eabfb"
 }

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;
-  };