@strapi/strapi 4.0.0-beta.0

package/lib/services/webhook-runner.js

@@ -0,0 +1,155 @@
+/**
+ * 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,
+        createdAt: 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);
+};

package/lib/services/webhook-store.js

@@ -0,0 +1,91 @@
+/**
+ * Webhook store is the implementation of webhook storage over the core_store
+ */
+'use strict';
+
+const webhookModel = {
+  uid: 'webhook',
+  collectionName: 'strapi_webhooks',
+  attributes: {
+    name: {
+      type: 'string',
+    },
+    url: {
+      type: 'text',
+    },
+    headers: {
+      type: 'json',
+    },
+    events: {
+      type: 'json',
+    },
+    enabled: {
+      type: 'boolean',
+    },
+  },
+};
+
+const toDBObject = data => {
+  return {
+    name: data.name,
+    url: data.url,
+    headers: data.headers,
+    events: data.events,
+    enabled: data.isEnabled,
+  };
+};
+
+const fromDBObject = row => {
+  return {
+    id: row.id,
+    name: row.name,
+    url: row.url,
+    headers: row.headers,
+    events: row.events,
+    isEnabled: row.enabled,
+  };
+};
+
+const createWebhookStore = ({ db }) => {
+  const webhookQueries = db.query('webhook');
+
+  return {
+    async findWebhooks() {
+      const results = await webhookQueries.findMany();
+
+      return results.map(fromDBObject);
+    },
+
+    async findWebhook(id) {
+      const result = await webhookQueries.findOne({ where: { id } });
+      return result ? fromDBObject(result) : null;
+    },
+
+    createWebhook(data) {
+      return webhookQueries
+        .create({
+          data: toDBObject({ ...data, isEnabled: true }),
+        })
+        .then(fromDBObject);
+    },
+
+    async updateWebhook(id, data) {
+      const webhook = await webhookQueries.update({
+        where: { id },
+        data: toDBObject(data),
+      });
+
+      return webhook ? fromDBObject(webhook) : null;
+    },
+
+    async deleteWebhook(id) {
+      const webhook = await webhookQueries.delete({ where: { id } });
+      return webhook ? fromDBObject(webhook) : null;
+    },
+  };
+};
+
+module.exports = {
+  webhookModel,
+  createWebhookStore,
+};

package/lib/services/worker-queue.js

@@ -0,0 +1,58 @@
+/**
+ * Simple worker queue in memory
+ */
+'use strict';
+
+const debug = require('debug')('strapi:worker-queue');
+
+module.exports = class WorkerQueue {
+  constructor({ logger, concurrency = 5 } = {}) {
+    debug('Initialize worker queue');
+
+    this.logger = logger;
+    this.worker = noop;
+
+    this.concurrency = concurrency;
+    this.running = 0;
+    this.queue = [];
+  }
+
+  subscribe(worker) {
+    debug('Subscribe to worker queue');
+    this.worker = worker;
+  }
+
+  enqueue(payload) {
+    debug('Enqueue event in worker queue');
+    if (this.running < this.concurrency) {
+      this.running++;
+      this.execute(payload);
+    } else {
+      this.queue.unshift(payload);
+    }
+  }
+
+  pop() {
+    debug('Pop worker queue and execute');
+    const payload = this.queue.pop();
+
+    if (payload) {
+      this.execute(payload);
+    } else {
+      this.running--;
+    }
+  }
+
+  async execute(payload) {
+    debug('Execute worker');
+    try {
+      await this.worker(payload);
+    } catch (error) {
+      this.logger.error(error);
+    } finally {
+      this.pop();
+    }
+  }
+};
+
+function noop() {}

package/lib/utils/addSlash.js

@@ -0,0 +1,10 @@
+'use strict';
+
+module.exports = path => {
+  if (typeof path !== 'string') throw new Error('admin.url must be a string');
+  if (path === '' || path === '/') return '/';
+
+  if (path[0] != '/') path = '/' + path;
+  if (path[path.length - 1] != '/') path = path + '/';
+  return path;
+};

package/lib/utils/ee.js

@@ -0,0 +1,123 @@
+'use strict';
+
+const path = require('path');
+const fs = require('fs');
+const crypto = require('crypto');
+const _ = require('lodash');
+
+const publicKey = fs.readFileSync(path.join(__dirname, '../utils/resources/key.pub'));
+
+const noop = () => {};
+
+const noLog = {
+  warn: noop,
+  info: noop,
+};
+
+const internals = {};
+const features = {
+  bronze: [],
+  silver: [],
+  gold: ['sso'],
+};
+
+module.exports = ({ dir, logger = noLog }) => {
+  if (_.has(internals, 'isEE')) return internals.isEE;
+
+  const warnAndReturn = (msg = 'Invalid license. Starting in CE.') => {
+    logger.warn(msg);
+    internals.isEE = false;
+    return false;
+  };
+
+  if (process.env.STRAPI_DISABLE_EE === 'true') {
+    internals.isEE = false;
+    return false;
+  }
+
+  const licensePath = path.join(dir, 'license.txt');
+
+  let license;
+  if (_.has(process.env, 'STRAPI_LICENSE')) {
+    license = process.env.STRAPI_LICENSE;
+  } else if (fs.existsSync(licensePath)) {
+    license = fs.readFileSync(licensePath).toString();
+  }
+
+  if (_.isNil(license)) {
+    internals.isEE = false;
+    return false;
+  }
+
+  try {
+    const plainLicense = Buffer.from(license, 'base64').toString();
+    const [signatureb64, contentb64] = plainLicense.split('\n');
+
+    const signature = Buffer.from(signatureb64, 'base64');
+    const content = Buffer.from(contentb64, 'base64').toString();
+
+    const verifier = crypto.createVerify('RSA-SHA256');
+    verifier.update(content);
+    verifier.end();
+
+    const isValid = verifier.verify(publicKey, signature);
+    if (!isValid) return warnAndReturn();
+
+    internals.licenseInfo = JSON.parse(content);
+
+    const expirationTime = new Date(internals.licenseInfo.expireAt).getTime();
+    if (expirationTime < new Date().getTime()) {
+      return warnAndReturn('License expired. Starting in CE');
+    }
+  } catch (err) {
+    return warnAndReturn();
+  }
+
+  internals.isEE = true;
+  return true;
+};
+
+Object.defineProperty(module.exports, 'licenseInfo', {
+  get() {
+    mustHaveKey('licenseInfo');
+    return internals.licenseInfo;
+  },
+  configurable: false,
+  enumerable: false,
+});
+
+Object.defineProperty(module.exports, 'isEE', {
+  get() {
+    mustHaveKey('isEE');
+    return internals.isEE;
+  },
+  configurable: false,
+  enumerable: false,
+});
+
+Object.defineProperty(module.exports, 'features', {
+  get() {
+    mustHaveKey('licenseInfo');
+
+    const { type: licenseType } = module.exports.licenseInfo;
+
+    return {
+      isEnabled(feature) {
+        return features[licenseType].includes(feature);
+      },
+      getEnabled() {
+        return features[licenseType];
+      },
+    };
+  },
+  configurable: false,
+  enumerable: false,
+});
+
+const mustHaveKey = key => {
+  if (!_.has(internals, key)) {
+    const err = new Error('Tampering with license');
+    // err.stack = null;
+    throw err;
+  }
+};

package/lib/utils/get-dirs.js

@@ -0,0 +1,15 @@
+'use strict';
+
+const { join } = require('path');
+
+const getDirs = root => ({
+  root,
+  src: join(root, 'src'),
+  api: join(root, 'src', 'api'),
+  components: join(root, 'src', 'components'),
+  extensions: join(root, 'src', 'extensions'),
+  policies: join(root, 'src', 'policies'),
+  config: join(root, 'config'),
+});
+
+module.exports = getDirs;

package/lib/utils/get-prefixed-dependencies.js

@@ -0,0 +1,7 @@
+'use strict';
+
+module.exports = (prefix, pkgJSON) => {
+  return Object.keys(pkgJSON.dependencies)
+    .filter(d => d.startsWith(prefix) && d.length > prefix.length)
+    .map(pkgName => pkgName.substring(prefix.length + 1));
+};

package/lib/utils/index.js

@@ -0,0 +1,11 @@
+'use strict';
+
+const openBrowser = require('./open-browser');
+const isInitialized = require('./is-initialized');
+const getDirs = require('./get-dirs');
+
+module.exports = {
+  isInitialized,
+  openBrowser,
+  getDirs,
+};

package/lib/utils/is-initialized.js

@@ -0,0 +1,23 @@
+'use strict';
+
+const { isEmpty, isNil } = require('lodash/fp');
+
+/**
+ * Test if the strapi application is considered as initialized (1st user has been created)
+ * @param {Strapi} strapi
+ * @returns {boolean}
+ */
+module.exports = async function isInitialized(strapi) {
+  try {
+    if (isEmpty(strapi.admin)) {
+      return true;
+    }
+
+    // test if there is at least one admin
+    const anyAdministrator = await strapi.query('admin::user').findOne({ select: ['id'] });
+
+    return !isNil(anyAdministrator);
+  } catch (err) {
+    strapi.stopWithError(err);
+  }
+};

package/lib/utils/open-browser.js

@@ -0,0 +1,12 @@
+'use strict';
+
+var open = require('open');
+const { getAbsoluteAdminUrl } = require('@strapi/utils');
+
+async function openBrowser(config) {
+  const url = getAbsoluteAdminUrl(config);
+
+  return open(url);
+}
+
+module.exports = openBrowser;

package/lib/utils/resources/key.pub

@@ -0,0 +1,9 @@
+-----BEGIN PUBLIC KEY-----
+MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEApuI1XlPkYos3WsSeVPtS
+l1Q2k8GnLEO5vFZ4EuSghMbqI+yE0tWVEaiptdV3KgERaALRXmH+IFrHqvSRjKQC
+1ORUarBU5ntWbNEr713R3K0BPOzz9OOoWHdk+Wmr4ViOTk0iD1u4bw/97RpyMoBm
++pXeBLHbEESK2kelk+LEmKUoY5nXp6KzZV5wxgD5QweZheU7mjXL5WMpIBJva8kp
+RZMYXEF+uSZIep0q5FHEo2AazGUMAU3GjY/dpXisLmtleOa1xlKZmkvaXl/D2Mhb
+BBqPbDMa72ToZg2J8K5UP9zXUP41FHr7o9rwSJ2uOkuZPg5nhDXeoVbrJwxP/U1M
+nQIDAQAB
+-----END PUBLIC KEY-----

package/lib/utils/run-checks.js

@@ -0,0 +1,22 @@
+'use strict';
+
+const path = require('path');
+const fs = require('fs-extra');
+
+const requiredPaths = ['api', 'extensions', 'plugins', 'config', 'public'];
+const checkFoldersExist = ({ appPath }) => {
+  let missingPaths = [];
+  for (let reqPath of requiredPaths) {
+    if (!fs.pathExistsSync(path.resolve(appPath, reqPath))) {
+      missingPaths.push(reqPath);
+    }
+  }
+
+  if (missingPaths.length > 0) {
+    throw new Error(`Missing required folders:\n${missingPaths.map(p => `- ./${p}`).join('\n')}`);
+  }
+};
+
+module.exports = config => {
+  checkFoldersExist(config);
+};

package/lib/utils/startup-logger.js

@@ -0,0 +1,90 @@
+'use strict';
+
+const chalk = require('chalk');
+const CLITable = require('cli-table3');
+const _ = require('lodash/fp');
+const { getAbsoluteAdminUrl, getAbsoluteServerUrl } = require('@strapi/utils');
+const ee = require('./ee');
+
+module.exports = app => {
+  return {
+    logStats() {
+      const columns = Math.min(process.stderr.columns, 80) - 2;
+      console.log();
+      console.log(chalk.black.bgWhite(_.padEnd(columns, ' Project information')));
+      console.log();
+
+      const infoTable = new CLITable({
+        colWidths: [20, 50],
+        chars: { mid: '', 'left-mid': '', 'mid-mid': '', 'right-mid': '' },
+      });
+
+      const isEE = app.EE === true && ee.isEE === true;
+
+      infoTable.push(
+        [chalk.blue('Time'), `${new Date()}`],
+        [chalk.blue('Launched in'), Date.now() - app.config.launchedAt + ' ms'],
+        [chalk.blue('Environment'), app.config.environment],
+        [chalk.blue('Process PID'), process.pid],
+        [chalk.blue('Version'), `${app.config.info.strapi} (node ${process.version})`],
+        [chalk.blue('Edition'), isEE ? 'Enterprise' : 'Community']
+      );
+
+      console.log(infoTable.toString());
+      console.log();
+      console.log(chalk.black.bgWhite(_.padEnd(columns, ' Actions available')));
+      console.log();
+    },
+
+    logFirstStartupMessage() {
+      this.logStats();
+
+      console.log(chalk.bold('One more thing...'));
+      console.log(
+        chalk.grey('Create your first administrator 💻 by going to the administration panel at:')
+      );
+      console.log();
+
+      const addressTable = new CLITable();
+
+      const adminUrl = getAbsoluteAdminUrl(strapi.config);
+      addressTable.push([chalk.bold(adminUrl)]);
+
+      console.log(`${addressTable.toString()}`);
+      console.log();
+    },
+
+    logDefaultStartupMessage() {
+      this.logStats();
+
+      console.log(chalk.bold('Welcome back!'));
+
+      if (app.config.serveAdminPanel === true) {
+        console.log(chalk.grey('To manage your project 🚀, go to the administration panel at:'));
+        const adminUrl = getAbsoluteAdminUrl(strapi.config);
+        console.log(chalk.bold(adminUrl));
+        console.log();
+      }
+
+      console.log(chalk.grey('To access the server ⚡️, go to:'));
+      const serverUrl = getAbsoluteServerUrl(strapi.config);
+      console.log(chalk.bold(serverUrl));
+      console.log();
+    },
+
+    logStartupMessage({ isInitialized } = {}) {
+      // Should the startup message be displayed?
+      const hideStartupMessage = process.env.STRAPI_HIDE_STARTUP_MESSAGE
+        ? process.env.STRAPI_HIDE_STARTUP_MESSAGE === 'true'
+        : false;
+
+      if (hideStartupMessage === false) {
+        if (!isInitialized) {
+          this.logFirstStartupMessage();
+        } else {
+          this.logDefaultStartupMessage();
+        }
+      }
+    },
+  };
+};

package/lib/utils/success.js

@@ -0,0 +1,31 @@
+'use strict';
+
+/**
+ * Module dependencies
+ */
+
+const fetch = require('node-fetch');
+const { machineIdSync } = require('node-machine-id');
+
+/*
+ * No need to worry about this file, we only retrieve anonymous data here.
+ * It allows us to know on how many times the package has been installed globally.
+ */
+
+try {
+  if (
+    process.env.npm_config_global === 'true' ||
+    JSON.parse(process.env.npm_config_argv).original.includes('global')
+  ) {
+    fetch('https://analytics.strapi.io/track', {
+      method: 'POST',
+      body: JSON.stringify({
+        event: 'didInstallStrapi',
+        deviceId: machineIdSync(),
+      }),
+      headers: { 'Content-Type': 'application/json' },
+    }).catch(() => {});
+  }
+} catch (e) {
+  //...
+}