@akemona-org/strapi 3.7.0

package/lib/services/entity-validator/validators.js

@@ -0,0 +1,125 @@
+'use strict';
+
+const _ = require('lodash');
+
+const { yup } = require('@akemona-org/strapi-utils');
+
+/**
+ * Utility function to compose validators
+ */
+const composeValidators =
+  (...fns) =>
+  (attr, { isDraft }) => {
+    return fns.reduce((validator, fn) => {
+      return fn(attr, validator, { isDraft });
+    }, yup.mixed());
+  };
+
+/* Validator utils */
+
+/**
+ * Adds minLength validator
+ * @param {Object} attribute model attribute
+ * @param {Object} validator yup validator
+ */
+const addMinLengthValidator = ({ minLength }, validator, { isDraft }) =>
+  _.isInteger(minLength) && !isDraft ? validator.min(minLength) : validator;
+
+/**
+ * Adds maxLength validator
+ * @param {Object} attribute model attribute
+ * @param {Object} validator yup validator
+ */
+const addMaxLengthValidator = ({ maxLength }, validator) =>
+  _.isInteger(maxLength) ? validator.max(maxLength) : validator;
+
+/**
+ * Adds min integer validator
+ * @param {Object} attribute model attribute
+ * @param {Object} validator yup validator
+ */
+const addMinIntegerValidator = ({ min }, validator) =>
+  _.isNumber(min) ? validator.min(_.toInteger(min)) : validator;
+
+/**
+ * Adds max integer validator
+ * @param {Object} attribute model attribute
+ * @param {Object} validator yup validator
+ */
+const addMaxIntegerValidator = ({ max }, validator) =>
+  _.isNumber(max) ? validator.max(_.toInteger(max)) : validator;
+
+/**
+ * Adds min float/decimal validator
+ * @param {Object} attribute model attribute
+ * @param {Object} validator yup validator
+ */
+const addMinFloatValidator = ({ min }, validator) =>
+  _.isNumber(min) ? validator.min(min) : validator;
+
+/**
+ * Adds max float/decimal validator
+ * @param {Object} attribute model attribute
+ * @param {Object} validator yup validator
+ */
+const addMaxFloatValidator = ({ max }, validator) =>
+  _.isNumber(max) ? validator.max(max) : validator;
+
+/**
+ * Adds regex validator
+ * @param {Object} attribute model attribute
+ * @param {Object} validator yup validator
+ */
+const addStringRegexValidator = ({ regex }, validator) =>
+  _.isUndefined(regex) ? validator : validator.matches(new RegExp(regex));
+
+/* Type validators */
+
+const stringValidator = composeValidators(
+  () => yup.string().transform((val, originalVal) => originalVal),
+  addMinLengthValidator,
+  addMaxLengthValidator,
+  addStringRegexValidator
+);
+
+const emailValidator = composeValidators(stringValidator, (attr, validator) => validator.email());
+
+const uidValidator = composeValidators(stringValidator, (attr, validator) =>
+  validator.matches(new RegExp('^[A-Za-z0-9-_.~]*$'))
+);
+
+const enumerationValidator = (attr) => {
+  return yup.string().oneOf((Array.isArray(attr.enum) ? attr.enum : [attr.enum]).concat(null));
+};
+
+const integerValidator = composeValidators(
+  () => yup.number().integer(),
+  addMinIntegerValidator,
+  addMaxIntegerValidator
+);
+
+const floatValidator = composeValidators(
+  () => yup.number(),
+  addMinFloatValidator,
+  addMaxFloatValidator
+);
+
+module.exports = {
+  string: stringValidator,
+  text: stringValidator,
+  richtext: stringValidator,
+  password: stringValidator,
+  email: emailValidator,
+  enumeration: enumerationValidator,
+  boolean: () => yup.boolean(),
+  uid: uidValidator,
+  json: () => yup.mixed(),
+  integer: integerValidator,
+  biginteger: () => yup.mixed(),
+  float: floatValidator,
+  decimal: floatValidator,
+  date: () => yup.mixed(),
+  time: () => yup.mixed(),
+  datetime: () => yup.mixed(),
+  timestamp: () => yup.mixed(),
+};

package/lib/services/event-hub.js

@@ -0,0 +1,15 @@
+/**
+ * The event hub is Strapi's event control center.
+ */
+'use strict';
+
+const EventEmitter = require('events');
+
+class EventHub extends EventEmitter {}
+
+/**
+ * Expose a factory function instead of the class
+ */
+module.exports = function createEventHub(opts) {
+  return new EventHub(opts);
+};

package/lib/services/metrics/index.js

@@ -0,0 +1,103 @@
+'use strict';
+/**
+ * Strapi telemetry package.
+ * You can learn more at https://strapi.akemona.com/documentation/developer-docs/latest/getting-started/usage-information.html
+ */
+
+const crypto = require('crypto');
+const fs = require('fs');
+const path = require('path');
+const { scheduleJob } = require('node-schedule');
+
+const ee = require('../../utils/ee');
+const wrapWithRateLimit = require('./rate-limiter');
+const createSender = require('./sender');
+const createMiddleware = require('./middleware');
+const isTruthy = require('./is-truthy');
+
+const LIMITED_EVENTS = [
+  'didSaveMediaWithAlternativeText',
+  'didSaveMediaWithCaption',
+  'didDisableResponsiveDimensions',
+  'didEnableResponsiveDimensions',
+];
+
+const createTelemetryInstance = strapi => {
+  const { uuid } = strapi.config;
+  const isDisabled = !uuid || isTruthy(process.env.STRAPI_TELEMETRY_DISABLED);
+
+  const crons = [];
+  const sender = createSender(strapi);
+  const sendEvent = wrapWithRateLimit(sender, { limitedEvents: LIMITED_EVENTS });
+
+  if (!isDisabled) {
+    const pingCron = scheduleJob('0 0 12 * * *', () => sendEvent('ping'));
+    crons.push(pingCron);
+
+    strapi.app.use(createMiddleware({ sendEvent }));
+  }
+
+  if (strapi.EE === true && ee.isEE === true) {
+    const pingDisabled =
+      isTruthy(process.env.STRAPI_LICENSE_PING_DISABLED) && ee.licenseInfo.type === 'gold';
+
+    const sendLicenseCheck = () => {
+      return sendEvent(
+        'didCheckLicense',
+        {
+          licenseInfo: {
+            ...ee.licenseInfo,
+            projectHash: hashProject(strapi),
+            dependencyHash: hashDep(strapi),
+          },
+        },
+        {
+          headers: { 'x-strapi-project': 'enterprise' },
+        }
+      );
+    };
+
+    if (!pingDisabled) {
+      const licenseCron = scheduleJob('0 0 0 * * 7', () => sendLicenseCheck());
+      crons.push(licenseCron);
+
+      sendLicenseCheck();
+    }
+  }
+
+  return {
+    destroy() {
+      // clear open handles
+      crons.forEach(cron => cron.cancel());
+    },
+    async send(event, payload) {
+      if (isDisabled) return true;
+      return sendEvent(event, payload);
+    },
+  };
+};
+
+const hash = str =>
+  crypto
+    .createHash('sha256')
+    .update(str)
+    .digest('hex');
+
+const hashProject = strapi => hash(`${strapi.config.info.name}${strapi.config.info.description}`);
+
+const hashDep = strapi => {
+  const depStr = JSON.stringify(strapi.config.info.dependencies);
+  const readmePath = path.join(strapi.dir, 'README.md');
+
+  try {
+    if (fs.existsSync(readmePath)) {
+      return hash(`${depStr}${fs.readFileSync(readmePath)}`);
+    }
+  } catch (err) {
+    return hash(`${depStr}`);
+  }
+
+  return hash(`${depStr}`);
+};
+
+module.exports = createTelemetryInstance;

package/lib/services/metrics/is-truthy.js

@@ -0,0 +1,9 @@
+'use strict';
+
+const _ = require('lodash');
+
+const isTruthy = val => {
+  return [1, true].includes(val) || ['true', '1'].includes(_.toLower(val));
+};
+
+module.exports = isTruthy;

package/lib/services/metrics/middleware.js

@@ -0,0 +1,33 @@
+'use strict';
+
+const createMiddleware = ({ sendEvent }) => {
+  const _state = {
+    currentDay: null,
+    counter: 0,
+  };
+
+  return async (ctx, next) => {
+    const { url, method } = ctx.request;
+
+    if (!url.includes('.') && ['GET', 'PUT', 'POST', 'DELETE'].includes(method)) {
+      const dayOfMonth = new Date().getDate();
+
+      if (dayOfMonth !== _state.currentDay) {
+        _state.currentDay = dayOfMonth;
+        _state.counter = 0;
+      }
+
+      // Send max. 1000 events per day.
+      if (_state.counter < 1000) {
+        sendEvent('didReceiveRequest', { url: ctx.request.url });
+
+        // Increase counter.
+        _state.counter++;
+      }
+    }
+
+    await next();
+  };
+};
+
+module.exports = createMiddleware;

package/lib/services/metrics/rate-limiter.js

@@ -0,0 +1,27 @@
+'use strict';
+
+/**
+ * @param events a list of events that need to be limited
+ */
+module.exports = (sender, { limitedEvents = [] } = {}) => {
+  let currentDay = new Date().getDate();
+  const eventCache = new Map();
+
+  return async (event, ...args) => {
+    if (!limitedEvents.includes(event)) {
+      return sender(event, ...args);
+    }
+
+    if (new Date().getDate() !== currentDay) {
+      eventCache.clear();
+      currentDay = new Date().getDate();
+    }
+
+    if (eventCache.has(event)) {
+      return false;
+    }
+
+    eventCache.set(event, true);
+    return sender(event, ...args);
+  };
+};

package/lib/services/metrics/sender.js

@@ -0,0 +1,76 @@
+'use strict';
+
+const os = require('os');
+const _ = require('lodash');
+const isDocker = require('is-docker');
+const { machineIdSync } = require('node-machine-id');
+const fetch = require('node-fetch');
+const ciEnv = require('ci-info');
+const ee = require('../../utils/ee');
+const stringifyDeep = require('./stringify-deep');
+
+const defaultQueryOpts = {
+  timeout: 1000,
+  headers: { 'Content-Type': 'application/json' },
+};
+
+const ANALYTICS_URI = 'https://analytics.strapi.io';
+
+/**
+ * Add properties from the package.json strapi key in the metadata
+ * @param {object} metadata
+ */
+const addPackageJsonStrapiMetadata = (metadata, strapi) => {
+  const { packageJsonStrapi = {} } = strapi.config;
+
+  _.defaults(metadata, packageJsonStrapi);
+};
+
+/**
+ * Create a send function for event with all the necessary metadatas
+ * @param {Object} strapi strapi app
+ * @returns {Function} (event, payload) -> Promise{boolean}
+ */
+module.exports = strapi => {
+  const { uuid } = strapi.config;
+  const deviceId = machineIdSync();
+  const isEE = strapi.EE === true && ee.isEE === true;
+
+  const anonymous_metadata = {
+    environment: strapi.config.environment,
+    os: os.type(),
+    osPlatform: os.platform(),
+    osRelease: os.release(),
+    nodeVersion: process.version,
+    docker: process.env.DOCKER || isDocker(),
+    isCI: ciEnv.isCI,
+    version: strapi.config.info.strapi,
+    strapiVersion: strapi.config.info.strapi,
+    projectType: isEE ? 'Enterprise' : 'Community',
+  };
+
+  addPackageJsonStrapiMetadata(anonymous_metadata, strapi);
+
+  return async (event, payload = {}, opts = {}) => {
+    const reqParams = {
+      method: 'POST',
+      body: JSON.stringify({
+        event,
+        uuid,
+        deviceId,
+        properties: stringifyDeep({
+          ...payload,
+          ...anonymous_metadata,
+        }),
+      }),
+      ..._.merge({}, defaultQueryOpts, opts),
+    };
+
+    try {
+      const res = await fetch(`${ANALYTICS_URI}/track`, reqParams);
+      return res.ok;
+    } catch (err) {
+      return false;
+    }
+  };
+};

package/lib/services/metrics/stringify-deep.js

@@ -0,0 +1,22 @@
+'use strict';
+
+const { map, mapValues, isObject, isArray, toString } = require('lodash/fp');
+
+/**
+ * Stringify all non object valutes before send them
+ * @param {object} obj
+ * @returns {object}
+ */
+const stringifyDeep = value => {
+  if (isArray(value)) {
+    return map(stringifyDeep, value);
+  }
+
+  if (isObject(value)) {
+    return mapValues(stringifyDeep, value);
+  }
+
+  return toString(value);
+};
+
+module.exports = stringifyDeep;

package/lib/services/utils/upload-files.js

@@ -0,0 +1,70 @@
+'use strict';
+
+const _ = require('lodash');
+
+module.exports = async (entry, files, { model, source }) => {
+  const entity = strapi.getModel(model, source);
+
+  if (!_.has(strapi.plugins, 'upload')) return entry;
+
+  const uploadService = strapi.plugins.upload.services.upload;
+
+  const findModelFromUploadPath = path => {
+    if (path.length === 0) return { model, source };
+
+    let currentPath = [];
+    let tmpModel = entity;
+    let modelName = model;
+    let sourceName;
+
+    for (let i = 0; i < path.length; i++) {
+      if (!tmpModel) return {};
+      const part = path[i];
+      const attr = tmpModel.attributes[part];
+
+      currentPath.push(part);
+
+      // ignore array indexes => handled in the dynamic zone section
+      if (_.isFinite(_.toNumber(path[i]))) {
+        continue;
+      }
+
+      if (!attr) return {};
+
+      if (attr.type === 'component') {
+        modelName = attr.component;
+        tmpModel = strapi.components[attr.component];
+      } else if (attr.type === 'dynamiczone') {
+        const entryIdx = path[i + 1]; // get component index
+        const value = _.get(entry, [...currentPath, entryIdx]);
+
+        if (!value) return {};
+
+        modelName = value.__component; // get component type
+        tmpModel = strapi.components[modelName];
+      } else if (_.has(attr, 'model') || _.has(attr, 'collection')) {
+        sourceName = attr.plugin;
+        modelName = attr.model || attr.collection;
+        tmpModel = strapi.getModel(attr.model || attr.collection, source);
+      } else {
+        return {};
+      }
+    }
+
+    return { model: modelName, source: sourceName };
+  };
+
+  const doUpload = async (key, files) => {
+    const parts = key.split('.');
+    const [path, field] = [_.initial(parts), _.last(parts)];
+
+    const { model, source } = findModelFromUploadPath(path);
+
+    if (model) {
+      const id = _.get(entry, path.concat('id'));
+      return uploadService.uploadToEntity({ id, model, field }, files, source);
+    }
+  };
+
+  await Promise.all(Object.keys(files).map(key => doUpload(key, files[key])));
+};

package/lib/services/webhook-runner.js

@@ -0,0 +1,159 @@
+/**
+ * The event hub is Strapi's event control center.
+ */
+'use strict';
+
+const debug = require('debug')('strapi:webhook');
+const _ = require('lodash');
+const fetch = require('node-fetch');
+
+const WorkerQueue = require('./worker-queue');
+
+const defaultConfiguration = {
+  defaultHeaders: {},
+};
+
+class WebhookRunner {
+  constructor({ eventHub, logger, configuration = {} }) {
+    debug('Initialized webhook runer');
+    this.eventHub = eventHub;
+    this.logger = logger;
+    this.webhooksMap = new Map();
+    this.listeners = new Map();
+
+    if (typeof configuration !== 'object') {
+      throw new Error(
+        'Invalid configuration provided to the webhookRunner.\nCheck your server.json -> webhooks configuration'
+      );
+    }
+
+    this.config = _.merge(defaultConfiguration, configuration);
+
+    this.queue = new WorkerQueue({ logger, concurency: 5 });
+    this.queue.subscribe(this.executeListener.bind(this));
+  }
+
+  deleteListener(event) {
+    debug(`Deleting listener for event '${event}'`);
+    if (this.listeners.has(event)) {
+      const fn = this.listeners.get(event);
+
+      this.eventHub.off(event, fn);
+      this.listeners.delete(event);
+    }
+  }
+
+  createListener(event) {
+    debug(`Creating listener for event '${event}'`);
+    if (this.listeners.has(event)) {
+      this.logger.error(
+        `The webhook runner is already listening for the event '${event}'. Did you mean to call .register() ?`
+      );
+    }
+
+    const listen = info => {
+      this.queue.enqueue({ event, info });
+    };
+
+    this.listeners.set(event, listen);
+    this.eventHub.on(event, listen);
+  }
+
+  async executeListener({ event, info }) {
+    debug(`Executing webhook for event '${event}'`);
+    const webhooks = this.webhooksMap.get(event) || [];
+    const activeWebhooks = webhooks.filter(
+      webhook => webhook.isEnabled === true
+    );
+
+    for (const webhook of activeWebhooks) {
+      await this.run(webhook, event, info).catch(error => {
+        this.logger.error('Error running webhook');
+        this.logger.error(error);
+      });
+    }
+  }
+
+  run(webhook, event, info = {}) {
+    const { url, headers } = webhook;
+
+    return fetch(url, {
+      method: 'post',
+      body: JSON.stringify({
+        event,
+        created_at: new Date(),
+        ...info,
+      }),
+      headers: {
+        ...this.config.defaultHeaders,
+        ...headers,
+        'X-Strapi-Event': event,
+        'Content-Type': 'application/json',
+      },
+      timeout: 10000,
+    })
+      .then(async res => {
+        if (res.ok) {
+          return {
+            statusCode: res.status,
+          };
+        }
+
+        return {
+          statusCode: res.status,
+          message: await res.text(),
+        };
+      })
+      .catch(err => {
+        return {
+          statusCode: 500,
+          message: err.message,
+        };
+      });
+  }
+
+  add(webhook) {
+    debug(`Registering webhook '${webhook.id}'`);
+    const { events } = webhook;
+
+    events.forEach(event => {
+      if (this.webhooksMap.has(event)) {
+        this.webhooksMap.get(event).push(webhook);
+      } else {
+        this.webhooksMap.set(event, [webhook]);
+        this.createListener(event);
+      }
+    });
+  }
+
+  update(webhook) {
+    debug(`Refreshing webhook '${webhook.id}'`);
+    this.remove(webhook);
+    this.add(webhook);
+  }
+
+  remove(webhook) {
+    debug(`Unregistering webhook '${webhook.id}'`);
+
+    this.webhooksMap.forEach((webhooks, event) => {
+      const filteredWebhooks = webhooks.filter(
+        value => value.id !== webhook.id
+      );
+
+      // Cleanup hanging listeners
+      if (filteredWebhooks.length === 0) {
+        this.webhooksMap.delete(event);
+        this.deleteListener(event);
+      } else {
+        this.webhooksMap.set(event, filteredWebhooks);
+      }
+    });
+  }
+}
+
+/**
+ * Expose a factory function instead of the class
+ */
+module.exports = function createWebhookRunner(opts) {
+  return new WebhookRunner(opts);
+};