@akemona-org/strapi 3.7.0

package/lib/services/webhook-store.js

@@ -0,0 +1,97 @@
+/**
+ * Webhook store is the implementation of webhook storage over the core_store
+ */
+'use strict';
+
+const webhookModel = config => ({
+  connection: config.get('database.defaultConnection'),
+  uid: 'strapi::webhooks',
+  globalId: 'StrapiWebhooks',
+  collectionName: 'strapi_webhooks',
+  info: {
+    name: 'Strapi webhooks',
+    description: '',
+  },
+  pluginOptions: {
+    'content-manager': {
+      visible: false,
+    },
+    'content-type-builder': {
+      visible: false,
+    },
+  },
+  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('strapi_webhooks');
+
+  return {
+    async findWebhooks() {
+      const results = await webhookQueries.find();
+
+      return results.map(fromDBObject);
+    },
+
+    async findWebhook(id) {
+      const result = await webhookQueries.findOne({ id });
+      return result ? fromDBObject(result) : null;
+    },
+
+    createWebhook(data) {
+      return webhookQueries.create(toDBObject({ ...data, isEnabled: true })).then(fromDBObject);
+    },
+
+    async updateWebhook(id, data) {
+      const webhook = await webhookQueries.update({ id }, toDBObject(data));
+      return webhook ? fromDBObject(webhook) : null;
+    },
+
+    async deleteWebhook(id) {
+      const webhook = await webhookQueries.delete({ 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-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,25 @@
+'use strict';
+
+// Dependencies.
+const { isEmpty } = require('lodash');
+const openBrowser = require('./openBrowser');
+
+module.exports = {
+  /*
+   * Return false where there is no administrator, otherwise return true.
+   */
+  async isInitialised(strapi) {
+    try {
+      if (isEmpty(strapi.admin)) {
+        return true;
+      }
+
+      const numberOfAdministrators = await strapi.query('user', 'admin').find({ _limit: 1 });
+
+      return numberOfAdministrators.length > 0;
+    } catch (err) {
+      strapi.stopWithError(err);
+    }
+  },
+  openBrowser,
+};

package/lib/utils/openBrowser.js

@@ -0,0 +1,145 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+'use strict';
+
+var execSync = require('child_process').execSync;
+var chalk = require('chalk');
+var spawn = require('cross-spawn');
+var opn = require('opn');
+const fetch = require('node-fetch');
+const { getAbsoluteAdminUrl } = require('@akemona-org/strapi-utils');
+
+// https://github.com/sindresorhus/opn#app
+var OSX_CHROME = 'google chrome';
+
+const Actions = Object.freeze({
+  NONE: 0,
+  BROWSER: 1,
+  SCRIPT: 2,
+});
+
+function getBrowserEnv() {
+  // Attempt to honor this environment variable.
+  // It is specific to the operating system.
+  // See https://github.com/sindresorhus/opn#app for documentation.
+  const value = process.env.BROWSER;
+  let action;
+  if (!value) {
+    // Default.
+    action = Actions.BROWSER;
+  } else if (value.toLowerCase().endsWith('.js')) {
+    action = Actions.SCRIPT;
+  } else if (value.toLowerCase() === 'none') {
+    action = Actions.NONE;
+  } else {
+    action = Actions.BROWSER;
+  }
+  return { action, value };
+}
+
+function executeNodeScript(scriptPath, url) {
+  const extraArgs = process.argv.slice(2);
+  const child = spawn('node', [scriptPath, ...extraArgs, url], {
+    stdio: 'inherit',
+  });
+  child.on('close', (code) => {
+    if (code !== 0) {
+      console.log();
+      console.log(chalk.red('The script specified as BROWSER environment variable failed.'));
+      console.log(`${chalk.cyan(scriptPath)} exited with code ${code}.`);
+      console.log();
+      return;
+    }
+  });
+  return true;
+}
+
+function startBrowserProcess(browser, url) {
+  // If we're on OS X, the user hasn't specifically
+  // requested a different browser, we can try opening
+  // Chrome with AppleScript. This lets us reuse an
+  // existing tab when possible instead of creating a new one.
+  const shouldTryOpenChromeWithAppleScript =
+    process.platform === 'darwin' && (typeof browser !== 'string' || browser === OSX_CHROME);
+
+  if (shouldTryOpenChromeWithAppleScript) {
+    try {
+      // Try our best to reuse existing tab
+      // on OS X Google Chrome with AppleScript
+      execSync('ps cax | grep "Google Chrome"');
+      execSync(`osascript resources/openChrome.applescript "${encodeURI(url)}"`, {
+        cwd: __dirname,
+        stdio: 'ignore',
+      });
+      return true;
+    } catch (err) {
+      strapi.log.error('Failed to open Google Chrome with AppleScript');
+    }
+  }
+
+  // Another special case: on OS X, check if BROWSER has been set to "open".
+  // In this case, instead of passing `open` to `opn` (which won't work),
+  // just ignore it (thus ensuring the intended behavior, i.e. opening the system browser):
+  // https://github.com/facebook/create-react-app/pull/1690#issuecomment-283518768
+  if (process.platform === 'darwin' && browser === 'open') {
+    browser = undefined;
+  }
+
+  // Fallback to opn
+  // (It will always open new tab)
+  try {
+    var options = { app: browser };
+    opn(url, options).catch(() => {}); // Prevent `unhandledRejection` error.
+    return true;
+  } catch (err) {
+    return false;
+  }
+}
+
+async function pingDashboard(url, multipleTime = false) {
+  try {
+    await fetch(url, { method: 'HEAD', timeout: 300, body: null });
+    // Inform the user that we're going to open the administration panel.
+    this.log.info('⏳ Opening the admin panel...');
+  } catch (e) {
+    if (e.code !== 'ECONNREFUSED' && e.type !== 'request-timeout') {
+      return console.error(e);
+    }
+
+    // Only display once.
+    if (!multipleTime) {
+      this.log.warn(`⚠️  The admin panel is unavailable... Impossible to open it in the browser.`);
+    }
+  }
+}
+
+/**
+ * Reads the BROWSER evironment variable and decides what to do with it. Returns
+ * true if it opened a browser or ran a node.js script, otherwise false.
+ */
+async function openBrowser() {
+  const url = getAbsoluteAdminUrl(strapi.config);
+
+  // Ping the dashboard to ensure it's available.
+  await pingDashboard.call(this, url);
+
+  const { action, value } = getBrowserEnv();
+  switch (action) {
+    case Actions.NONE:
+      // Special case: BROWSER="none" will prevent opening completely.
+      return false;
+    case Actions.SCRIPT:
+      return executeNodeScript(value, url);
+    case Actions.BROWSER:
+      return startBrowserProcess(value, url);
+    default:
+      throw new Error('Not implemented.');
+  }
+}
+
+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/resources/openChrome.applescript

@@ -0,0 +1,83 @@
+(*
+Copyright (c) 2015-present, Facebook, Inc.
+
+This source code is licensed under the MIT license found in the
+LICENSE file in the root directory of this source tree.
+*)
+
+property targetTab: null
+property targetTabIndex: -1
+property targetWindow: null
+
+on run argv
+  set theURL to item 1 of argv
+
+  tell application "Chrome"
+
+    if (count every window) = 0 then
+      make new window
+    end if
+
+    -- 1: Looking for tab running debugger
+    -- then, Reload debugging tab if found
+    -- then return
+    set found to my lookupTabWithUrl(theURL)
+    if found then
+      set targetWindow's active tab index to targetTabIndex
+      tell targetTab to reload
+      tell targetWindow to activate
+      set index of targetWindow to 1
+      return
+    end if
+
+    -- 2: Looking for Empty tab
+    -- In case debugging tab was not found
+    -- We try to find an empty tab instead
+    set found to my lookupTabWithUrl("chrome://newtab/")
+    if found then
+      set targetWindow's active tab index to targetTabIndex
+      set URL of targetTab to theURL
+      tell targetWindow to activate
+      return
+    end if
+
+    -- 3: Create new tab
+    -- both debugging and empty tab were not found
+    -- make a new tab with url
+    tell window 1
+      activate
+      make new tab with properties {URL:theURL}
+    end tell
+  end tell
+end run
+
+-- Function:
+-- Lookup tab with given url
+-- if found, store tab, index, and window in properties
+-- (properties were declared on top of file)
+on lookupTabWithUrl(lookupUrl)
+  tell application "Chrome"
+    -- Find a tab with the given url
+    set found to false
+    set theTabIndex to -1
+    repeat with theWindow in every window
+      set theTabIndex to 0
+      repeat with theTab in every tab of theWindow
+        set theTabIndex to theTabIndex + 1
+        if (theTab's URL as string) contains lookupUrl then
+          -- assign tab, tab index, and window to properties
+          set targetTab to theTab
+          set targetTabIndex to theTabIndex
+          set targetWindow to theWindow
+          set found to true
+          exit repeat
+        end if
+      end repeat
+
+      if found then
+        exit repeat
+      end if
+    end repeat
+  end tell
+  return found
+end lookupTabWithUrl

package/lib/utils/run-checks.js

@@ -0,0 +1,37 @@
+'use strict';
+
+const path = require('path');
+const fs = require('fs-extra');
+const _ = require('lodash');
+
+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')}`);
+  }
+};
+
+const checkPluginsConflicts = ({ appPath, installedPlugins }) => {
+  const localPluginNames = fs.readdirSync(path.resolve(appPath, 'plugins'));
+  const pluginsIntersection = _.intersection(localPluginNames, installedPlugins);
+
+  if (pluginsIntersection.length > 0) {
+    throw new Error(
+      `You have some local plugins with the same name as npm installed plugins:\n${pluginsIntersection
+        .map(p => `- ${p}`)
+        .join('\n')}`
+    );
+  }
+};
+
+module.exports = config => {
+  checkFoldersExist(config);
+  checkPluginsConflicts(config);
+};

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) {
+  //...
+} */