@strapi/utils 4.11.3 → 4.12.0-beta.0

package/lib/parse-type.js

@@ -1,100 +0,0 @@
-'use strict';
-
-const _ = require('lodash');
-const dates = require('date-fns');
-
-const timeRegex = /^(2[0-3]|[01][0-9]):([0-5][0-9]):([0-5][0-9])(.[0-9]{1,3})?$/;
-
-const parseTime = (value) => {
-  if (dates.isDate(value)) return dates.format(value, 'HH:mm:ss.SSS');
-
-  if (typeof value !== 'string') {
-    throw new Error(`Expected a string, got a ${typeof value}`);
-  }
-  const result = value.match(timeRegex);
-
-  if (result === null) {
-    throw new Error('Invalid time format, expected HH:mm:ss.SSS');
-  }
-
-  const [, hours, minutes, seconds, fraction = '.000'] = result;
-  const fractionPart = _.padEnd(fraction.slice(1), 3, '0');
-
-  return `${hours}:${minutes}:${seconds}.${fractionPart}`;
-};
-
-const parseDate = (value) => {
-  if (dates.isDate(value)) return dates.format(value, 'yyyy-MM-dd');
-  try {
-    const date = dates.parseISO(value);
-
-    if (dates.isValid(date)) return dates.format(date, 'yyyy-MM-dd');
-
-    throw new Error(`Invalid format, expected an ISO compatible date`);
-  } catch (error) {
-    throw new Error(`Invalid format, expected an ISO compatible date`);
-  }
-};
-
-const parseDateTimeOrTimestamp = (value) => {
-  if (dates.isDate(value)) return value;
-  try {
-    const date = dates.parseISO(value);
-    if (dates.isValid(date)) return date;
-
-    const milliUnixDate = dates.parse(value, 'T', new Date());
-    if (dates.isValid(milliUnixDate)) return milliUnixDate;
-
-    throw new Error(`Invalid format, expected a timestamp or an ISO date`);
-  } catch (error) {
-    throw new Error(`Invalid format, expected a timestamp or an ISO date`);
-  }
-};
-
-/**
- * Cast basic values based on attribute type
- * @param {Object} options - Options
- * @param {string} options.type - type of the atribute
- * @param {*} options.value - value tu cast
- */
-const parseType = ({ type, value, forceCast = false }) => {
-  switch (type) {
-    case 'boolean': {
-      if (typeof value === 'boolean') return value;
-
-      if (['true', 't', '1', 1].includes(value)) {
-        return true;
-      }
-
-      if (['false', 'f', '0', 0].includes(value)) {
-        return false;
-      }
-
-      if (forceCast) {
-        return Boolean(value);
-      }
-
-      throw new Error('Invalid boolean input. Expected "t","1","true","false","0","f"');
-    }
-    case 'integer':
-    case 'biginteger':
-    case 'float':
-    case 'decimal': {
-      return _.toNumber(value);
-    }
-    case 'time': {
-      return parseTime(value);
-    }
-    case 'date': {
-      return parseDate(value);
-    }
-    case 'timestamp':
-    case 'datetime': {
-      return parseDateTimeOrTimestamp(value);
-    }
-    default:
-      return value;
-  }
-};
-
-module.exports = parseType;

package/lib/policy.js

@@ -1,129 +0,0 @@
-/**
- * Policies util
- */
-
-'use strict';
-
-const _ = require('lodash');
-const { eq } = require('lodash/fp');
-
-const PLUGIN_PREFIX = 'plugin::';
-const API_PREFIX = 'api::';
-
-const parsePolicy = (policy) => {
-  if (typeof policy === 'string') {
-    return { policyName: policy, config: {} };
-  }
-
-  const { name, config } = policy;
-  return { policyName: name, config };
-};
-
-const searchLocalPolicy = (policyName, { pluginName, apiName }) => {
-  if (pluginName) {
-    return strapi.policy(`${PLUGIN_PREFIX}${pluginName}.${policyName}`);
-  }
-
-  if (apiName) {
-    return strapi.policy(`${API_PREFIX}${apiName}.${policyName}`);
-  }
-};
-
-const globalPolicy = ({ method, endpoint, controller, action, plugin }) => {
-  return async (ctx, next) => {
-    ctx.request.route = {
-      endpoint: `${method} ${endpoint}`,
-      controller: _.toLower(controller),
-      action: _.toLower(action),
-      verb: _.toLower(method),
-      plugin,
-    };
-
-    await next();
-  };
-};
-
-const resolvePolicies = (config, { pluginName, apiName } = {}) => {
-  return config.map((policyConfig) => {
-    return {
-      handler: getPolicy(policyConfig, { pluginName, apiName }),
-      config: policyConfig.config || {},
-    };
-  });
-};
-
-const findPolicy = (name, { pluginName, apiName } = {}) => {
-  const resolvedPolicy = strapi.policy(name);
-
-  if (resolvedPolicy !== undefined) {
-    return resolvedPolicy;
-  }
-
-  const localPolicy = searchLocalPolicy(name, { pluginName, apiName });
-
-  if (localPolicy !== undefined) {
-    return localPolicy;
-  }
-
-  throw new Error(`Could not find policy "${name}"`);
-};
-
-const getPolicy = (policyConfig, { pluginName, apiName } = {}) => {
-  if (typeof policyConfig === 'function') {
-    return policyConfig;
-  }
-
-  const { policyName, config } = parsePolicy(policyConfig);
-
-  const policy = findPolicy(policyName, { pluginName, apiName });
-
-  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) {
-      try {
-        validator(config);
-      } catch (e) {
-        throw new Error(`Invalid config passed to "${name}" policy.`);
-      }
-    }
-  };
-
-  return {
-    name,
-    validator: wrappedValidator,
-    handler,
-  };
-};
-
-const createPolicyContext = (type, ctx) => {
-  return Object.assign(
-    {
-      is: eq(type),
-      get type() {
-        return type;
-      },
-    },
-    ctx
-  );
-};
-
-module.exports = {
-  get: getPolicy,
-  resolve: resolvePolicies,
-  globalPolicy,
-  createPolicy,
-  createPolicyContext,
-};

package/lib/print-value.js

@@ -1,52 +0,0 @@
-'use strict';
-
-// Code copied from the yup library (https://github.com/jquense/yup)
-// https://github.com/jquense/yup/blob/2778b88bdacd5260d593c6468793da2e77daf21f/src/util/printValue.ts
-
-const { toString } = Object.prototype;
-const errorToString = Error.prototype.toString;
-const regExpToString = RegExp.prototype.toString;
-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}`;
-}
-
-function printSimpleValue(val, quoteStrings = false) {
-  if (val == null || val === true || val === false) return `${val}`;
-
-  const typeOf = typeof val;
-  if (typeOf === 'number') return printNumber(val);
-  if (typeOf === 'string') return quoteStrings ? `"${val}"` : val;
-  if (typeOf === 'function') return `[Function ${val.name || 'anonymous'}]`;
-  if (typeOf === 'symbol') return symbolToString.call(val).replace(SYMBOL_REGEXP, 'Symbol($1)');
-
-  const tag = toString.call(val).slice(8, -1);
-  if (tag === 'Date') return Number.isNaN(val.getTime()) ? `${val}` : val.toISOString(val);
-  if (tag === 'Error' || val instanceof Error) return `[${errorToString.call(val)}]`;
-  if (tag === 'RegExp') return regExpToString.call(val);
-
-  return null;
-}
-
-function printValue(value, quoteStrings) {
-  const result = printSimpleValue(value, quoteStrings);
-  if (result !== null) return result;
-
-  return JSON.stringify(
-    value,
-    function replacer(key, value) {
-      const result = printSimpleValue(this[key], quoteStrings);
-      if (result !== null) return result;
-      return value;
-    },
-    2
-  );
-}
-
-module.exports = printValue;

package/lib/provider-factory.js

@@ -1,116 +0,0 @@
-'use strict';
-
-const { cloneDeep } = require('lodash/fp');
-const { createAsyncSeriesHook, createAsyncParallelHook } = require('./hooks');
-
-/**
- * @typedef ProviderHooksMap
- * @property willRegister
- * @property didRegister
- * @property willDelete
- * @property didDelete
- */
-
-/**
- * Creates a new object containing various hooks used by the providers
- * @return {ProviderHooksMap}
- */
-const createProviderHooksMap = () => ({
-  // Register events
-  willRegister: createAsyncSeriesHook(),
-  didRegister: createAsyncParallelHook(),
-  // Delete events
-  willDelete: createAsyncParallelHook(),
-  didDelete: createAsyncParallelHook(),
-});
-
-/**
- * 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
- */
-const providerFactory = (options = {}) => {
-  const { throwOnDuplicates = true } = options;
-
-  const state = {
-    hooks: createProviderHooksMap(),
-    registry: new Map(),
-  };
-
-  return {
-    hooks: state.hooks,
-
-    async register(key, item) {
-      if (throwOnDuplicates && this.has(key)) {
-        throw new Error(`Duplicated item key: ${key}`);
-      }
-
-      await state.hooks.willRegister.call({ key, value: item });
-
-      state.registry.set(key, item);
-
-      await state.hooks.didRegister.call({ key, value: cloneDeep(item) });
-
-      return this;
-    },
-
-    async delete(key) {
-      if (this.has(key)) {
-        const item = this.get(key);
-
-        await state.hooks.willDelete.call({ key, value: cloneDeep(item) });
-
-        state.registry.delete(key);
-
-        await state.hooks.didDelete.call({ key, value: cloneDeep(item) });
-      }
-
-      return this;
-    },
-
-    get(key) {
-      return state.registry.get(key);
-    },
-
-    getWhere(filters = {}) {
-      const items = this.values();
-      const filtersEntries = Object.entries(filters);
-
-      if (filtersEntries.length === 0) {
-        return items;
-      }
-
-      return items.filter((item) => {
-        return filtersEntries.every(([key, value]) => item[key] === value);
-      });
-    },
-
-    values() {
-      return Array.from(state.registry.values());
-    },
-
-    keys() {
-      return Array.from(state.registry.keys());
-    },
-
-    has(key) {
-      return state.registry.has(key);
-    },
-
-    size() {
-      return state.registry.size;
-    },
-
-    async clear() {
-      const keys = this.keys();
-
-      for (const key of keys) {
-        await this.delete(key);
-      }
-
-      return this;
-    },
-  };
-};
-
-module.exports = providerFactory;

package/lib/relations.js

@@ -1,31 +0,0 @@
-'use strict';
-
-const { isRelationalAttribute } = require('./content-types');
-
-const MANY_RELATIONS = ['oneToMany', 'manyToMany'];
-
-const getRelationalFields = (contentType) => {
-  return Object.keys(contentType.attributes).filter((attributeName) => {
-    return contentType.attributes[attributeName].type === 'relation';
-  });
-};
-
-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

@@ -1,143 +0,0 @@
-'use strict';
-
-const { isArray, cloneDeep } = require('lodash/fp');
-
-const { getNonWritableAttributes } = require('../content-types');
-const { pipeAsync } = require('../async');
-
-const visitors = require('./visitors');
-const sanitizers = require('./sanitizers');
-const traverseEntity = require('../traverse-entity');
-
-const { traverseQueryFilters, traverseQuerySort, traverseQueryPopulate } = require('../traverse');
-
-const createContentAPISanitizers = () => {
-  const sanitizeInput = (data, schema, { auth } = {}) => {
-    if (isArray(data)) {
-      return Promise.all(data.map((entry) => sanitizeInput(entry, schema, { auth })));
-    }
-
-    const nonWritableAttributes = getNonWritableAttributes(schema);
-
-    const transforms = [
-      // Remove non writable attributes
-      traverseEntity(visitors.restrictedFields(nonWritableAttributes), { schema }),
-    ];
-
-    if (auth) {
-      // Remove restricted relations
-      transforms.push(traverseEntity(visitors.removeRestrictedRelations(auth), { schema }));
-    }
-
-    // Apply sanitizers from registry if exists
-    strapi.sanitizers
-      .get('content-api.input')
-      .forEach((sanitizer) => transforms.push(sanitizer(schema)));
-
-    return pipeAsync(...transforms)(data);
-  };
-
-  const sanitizeOutput = async (data, schema, { auth } = {}) => {
-    if (isArray(data)) {
-      const res = new Array(data.length);
-      for (let i = 0; i < data.length; i += 1) {
-        res[i] = await sanitizeOutput(data[i], schema, { auth });
-      }
-      return res;
-    }
-
-    const transforms = [(data) => sanitizers.defaultSanitizeOutput(schema, data)];
-
-    if (auth) {
-      transforms.push(traverseEntity(visitors.removeRestrictedRelations(auth), { schema }));
-    }
-
-    // Apply sanitizers from registry if exists
-    strapi.sanitizers
-      .get('content-api.output')
-      .forEach((sanitizer) => transforms.push(sanitizer(schema)));
-
-    return pipeAsync(...transforms)(data);
-  };
-
-  const sanitizeQuery = async (query, schema, { auth } = {}) => {
-    const { filters, sort, fields, populate } = query;
-
-    const sanitizedQuery = cloneDeep(query);
-
-    if (filters) {
-      Object.assign(sanitizedQuery, { filters: await sanitizeFilters(filters, schema, { auth }) });
-    }
-
-    if (sort) {
-      Object.assign(sanitizedQuery, { sort: await sanitizeSort(sort, schema, { auth }) });
-    }
-
-    if (fields) {
-      Object.assign(sanitizedQuery, { fields: await sanitizeFields(fields, schema) });
-    }
-
-    if (populate) {
-      Object.assign(sanitizedQuery, { populate: await sanitizePopulate(populate, schema) });
-    }
-
-    return sanitizedQuery;
-  };
-
-  const sanitizeFilters = (filters, schema, { auth } = {}) => {
-    if (isArray(filters)) {
-      return Promise.all(filters.map((filter) => sanitizeFilters(filter, schema, { auth })));
-    }
-
-    const transforms = [sanitizers.defaultSanitizeFilters(schema)];
-
-    if (auth) {
-      transforms.push(traverseQueryFilters(visitors.removeRestrictedRelations(auth), { schema }));
-    }
-
-    return pipeAsync(...transforms)(filters);
-  };
-
-  const sanitizeSort = (sort, schema, { auth } = {}) => {
-    const transforms = [sanitizers.defaultSanitizeSort(schema)];
-
-    if (auth) {
-      transforms.push(traverseQuerySort(visitors.removeRestrictedRelations(auth), { schema }));
-    }
-
-    return pipeAsync(...transforms)(sort);
-  };
-
-  const sanitizeFields = (fields, schema) => {
-    const transforms = [sanitizers.defaultSanitizeFields(schema)];
-
-    return pipeAsync(...transforms)(fields);
-  };
-
-  const sanitizePopulate = (populate, schema, { auth } = {}) => {
-    const transforms = [sanitizers.defaultSanitizePopulate(schema)];
-
-    if (auth) {
-      transforms.push(traverseQueryPopulate(visitors.removeRestrictedRelations(auth), { schema }));
-    }
-
-    return pipeAsync(...transforms)(populate);
-  };
-
-  return {
-    input: sanitizeInput,
-    output: sanitizeOutput,
-    query: sanitizeQuery,
-    filters: sanitizeFilters,
-    sort: sanitizeSort,
-    fields: sanitizeFields,
-    populate: sanitizePopulate,
-  };
-};
-
-module.exports = {
-  contentAPI: createContentAPISanitizers(),
-
-  sanitizers,
-  visitors,
-};