@strapi/utils 4.0.0-beta.11 → 4.0.0-beta.15

package/lib/content-types.js

@@ -1,6 +1,7 @@
 'use strict';
 
 const _ = require('lodash');
+const { has } = require('lodash/fp');
 
 const SINGLE_TYPE = 'singleType';
 const COLLECTION_TYPE = 'collectionType';
@@ -31,8 +32,18 @@ const constants = {
   COLLECTION_TYPE,
 };
 
-const getTimestamps = () => {
-  return [CREATED_AT_ATTRIBUTE, UPDATED_AT_ATTRIBUTE];
+const getTimestamps = model => {
+  const attributes = [];
+
+  if (has(CREATED_AT_ATTRIBUTE, model.attributes)) {
+    attributes.push(CREATED_AT_ATTRIBUTE);
+  }
+
+  if (has(UPDATED_AT_ATTRIBUTE, model.attributes)) {
+    attributes.push(UPDATED_AT_ATTRIBUTE);
+  }
+
+  return attributes;
 };
 
 const getNonWritableAttributes = (model = {}) => {
@@ -42,7 +53,7 @@ const getNonWritableAttributes = (model = {}) => {
     []
   );
 
-  return _.uniq([ID_ATTRIBUTE, ...getTimestamps(), ...nonWritableAttributes]);
+  return _.uniq([ID_ATTRIBUTE, ...getTimestamps(model), ...nonWritableAttributes]);
 };
 
 const getWritableAttributes = (model = {}) => {
@@ -60,7 +71,7 @@ const getNonVisibleAttributes = model => {
     []
   );
 
-  return _.uniq([ID_ATTRIBUTE, ...getTimestamps(), ...nonVisibleAttributes]);
+  return _.uniq([ID_ATTRIBUTE, ...getTimestamps(model), ...nonVisibleAttributes]);
 };
 
 const getVisibleAttributes = model => {
@@ -137,6 +148,7 @@ module.exports = {
   isWritableAttribute,
   getNonVisibleAttributes,
   getVisibleAttributes,
+  getTimestamps,
   isVisibleAttribute,
   hasDraftAndPublish,
   isDraft,

package/lib/index.js

@@ -33,6 +33,7 @@ const providerFactory = require('./provider-factory');
 const pagination = require('./pagination');
 const sanitize = require('./sanitize');
 const traverseEntity = require('./traverse-entity');
+const pipeAsync = require('./pipe-async');
 
 module.exports = {
   yup,
@@ -66,6 +67,7 @@ module.exports = {
   hooks,
   providerFactory,
   pagination,
+  pipeAsync,
   errors,
   validateYupSchema,
   validateYupSchemaSync,

package/lib/{sanitize/utils.js → pipe-async.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-const pipeAsync = (...methods) => async data => {
+module.exports = (...methods) => async data => {
   let res = data;
 
   for (const method of methods) {
@@ -9,7 +9,3 @@ const pipeAsync = (...methods) => async data => {
 
   return res;
 };
-
-module.exports = {
-  pipeAsync,
-};

package/lib/policy.js

@@ -9,36 +9,22 @@ const { eq } = require('lodash/fp');
 const PLUGIN_PREFIX = 'plugin::';
 const API_PREFIX = 'api::';
 
-const createPolicy = (policyName, config) => ({ policyName, config });
-
-const resolveHandler = policy => {
-  return _.has('handler', policy) ? policy.handler : policy;
-};
-
 const parsePolicy = policy => {
   if (typeof policy === 'string') {
-    return createPolicy(policy);
+    return { policyName: policy, config: {} };
   }
 
-  const { name, config = {} } = policy;
-  return createPolicy(name, config);
-};
-
-const resolvePolicy = policyName => {
-  const policy = strapi.policy(policyName);
-
-  return resolveHandler(policy);
+  const { name, config } = policy;
+  return { policyName: name, config };
 };
 
 const searchLocalPolicy = (policyName, { pluginName, apiName }) => {
   if (pluginName) {
-    const policy = strapi.policy(`${PLUGIN_PREFIX}${pluginName}.${policyName}`);
-    return resolveHandler(policy);
+    return strapi.policy(`${PLUGIN_PREFIX}${pluginName}.${policyName}`);
   }
 
   if (apiName) {
-    const policy = strapi.policy(`${API_PREFIX}${apiName}.${policyName}`);
-    return resolveHandler(policy);
+    return strapi.policy(`${API_PREFIX}${apiName}.${policyName}`);
   }
 };
 
@@ -56,45 +42,68 @@ const globalPolicy = ({ method, endpoint, controller, action, plugin }) => {
   };
 };
 
-const get = (policy, { pluginName, apiName } = {}) => {
-  if (typeof policy === 'function') {
-    return policy;
-  }
-
-  const { policyName, config } = parsePolicy(policy);
+const resolvePolicies = (config, { pluginName, apiName } = {}) => {
+  return config.map(policyConfig => {
+    return {
+      handler: getPolicy(policyConfig, { pluginName, apiName }),
+      config: policyConfig.config || {},
+    };
+  });
+};
 
-  const resolvedPolicy = resolvePolicy(policyName);
+const findPolicy = (name, { pluginName, apiName } = {}) => {
+  const resolvedPolicy = strapi.policy(name);
 
   if (resolvedPolicy !== undefined) {
-    return _.isPlainObject(policy) ? resolvedPolicy(config) : resolvedPolicy;
+    return resolvedPolicy;
   }
 
-  const localPolicy = searchLocalPolicy(policy, { pluginName, apiName });
+  const localPolicy = searchLocalPolicy(name, { pluginName, apiName });
 
   if (localPolicy !== undefined) {
     return localPolicy;
   }
 
-  throw new Error(`Could not find policy "${policy}"`);
+  throw new Error(`Could not find policy "${name}"`);
 };
 
-const createPolicyFactory = (factoryCallback, options) => {
-  const { validator, name = 'unnamed' } = options;
+const getPolicy = (policyConfig, { pluginName, apiName } = {}) => {
+  if (typeof policyConfig === 'function') {
+    return policyConfig;
+  }
 
-  const validate = (...args) => {
-    try {
-      validator(...args);
-    } catch (e) {
-      throw new Error(`Invalid objects submitted to "${name}" policy.`);
-    }
-  };
+  const { policyName, config } = parsePolicy(policyConfig);
+
+  const policy = findPolicy(policyName, { pluginName, apiName });
 
-  return config => {
+  if (typeof policy === 'function') {
+    return policy;
+  }
+
+  if (policy.validator) {
+    policy.validator(config);
+  }
+
+  return policy.handler;
+};
+
+const createPolicy = options => {
+  const { name = 'unnamed', validator, handler } = options;
+
+  const wrappedValidator = config => {
     if (validator) {
-      validate(config);
+      try {
+        validator(config);
+      } catch (e) {
+        throw new Error(`Invalid config passed to "${name}" policy.`);
+      }
     }
+  };
 
-    return factoryCallback(config);
+  return {
+    name,
+    validator: wrappedValidator,
+    handler,
   };
 };
 
@@ -102,7 +111,6 @@ const createPolicyContext = (type, ctx) => {
   return Object.assign(
     {
       is: eq(type),
-
       get type() {
         return type;
       },
@@ -112,8 +120,9 @@ const createPolicyContext = (type, ctx) => {
 };
 
 module.exports = {
-  get,
+  get: getPolicy,
+  resolve: resolvePolicies,
   globalPolicy,
-  createPolicyFactory,
+  createPolicy,
   createPolicyContext,
 };

package/lib/sanitize/index.js

@@ -4,8 +4,10 @@ const { isArray } = require('lodash/fp');
 
 const traverseEntity = require('../traverse-entity');
 const { getNonWritableAttributes } = require('../content-types');
+const pipeAsync = require('../pipe-async');
+
 const visitors = require('./visitors');
-const utils = require('./utils');
+const sanitizers = require('./sanitizers');
 
 module.exports = {
   contentAPI: {
@@ -26,7 +28,7 @@ module.exports = {
         transforms.push(traverseEntity(visitors.removeRestrictedRelations(auth), { schema }));
       }
 
-      return utils.pipeAsync(...transforms)(data);
+      return pipeAsync(...transforms)(data);
     },
 
     output(data, schema, { auth } = {}) {
@@ -34,30 +36,16 @@ module.exports = {
         return Promise.all(data.map(entry => this.output(entry, schema, { auth })));
       }
 
-      const transforms = [
-        traverseEntity(visitors.removePassword, { schema }),
-        traverseEntity(visitors.removePrivate, { schema }),
-      ];
+      const transforms = [sanitizers.defaultSanitizeOutput(schema)];
 
       if (auth) {
         transforms.push(traverseEntity(visitors.removeRestrictedRelations(auth), { schema }));
       }
 
-      return utils.pipeAsync(...transforms)(data);
+      return pipeAsync(...transforms)(data);
     },
   },
 
-  eventHub(data, schema) {
-    if (isArray(data)) {
-      return Promise.all(data.map(entry => this.eventHub(entry, schema)));
-    }
-
-    return utils.pipeAsync(
-      traverseEntity(visitors.removePassword, { schema }),
-      traverseEntity(visitors.removePrivate, { schema })
-    )(data);
-  },
-
-  utils,
+  sanitizers,
   visitors,
 };

package/lib/sanitize/sanitizers.js

@@ -0,0 +1,26 @@
+'use strict';
+
+const { curry } = require('lodash/fp');
+
+const pipeAsync = require('../pipe-async');
+const traverseEntity = require('../traverse-entity');
+
+const { removePassword, removePrivate } = require('./visitors');
+
+const sanitizePasswords = curry((schema, entity) => {
+  return traverseEntity(removePassword, { schema }, entity);
+});
+
+const sanitizePrivates = curry((schema, entity) => {
+  return traverseEntity(removePrivate, { schema }, entity);
+});
+
+const defaultSanitizeOutput = curry((schema, entity) => {
+  return pipeAsync(sanitizePrivates(schema), sanitizePasswords(schema))(entity);
+});
+
+module.exports = {
+  sanitizePasswords,
+  sanitizePrivates,
+  defaultSanitizeOutput,
+};

package/lib/sanitize/visitors/allowed-fields.js

@@ -16,7 +16,7 @@ module.exports = (allowedFields = null) => ({ key, path }, { remove }) => {
   const containedPaths = getContainedPaths(path);
 
   /**
-   * Tells if the current path should be keeped or not based
+   * Tells if the current path should be kept or not based
    * on the success of the check functions for any of the allowed paths.
    *
    * The check functions are defined as follow:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strapi/utils",
-  "version": "4.0.0-beta.11",
+  "version": "4.0.0-beta.15",
   "description": "Shared utilities for the Strapi packages",
   "homepage": "https://strapi.io",
   "keywords": [
@@ -42,5 +42,5 @@
     "npm": ">=6.0.0"
   },
   "license": "SEE LICENSE IN LICENSE",
-  "gitHead": "5b04fa152dc597fc3aa80afb25796217b60403f3"
+  "gitHead": "c69713bf7f437a7cee66ffdeed95227d6246a872"
 }