@strapi/strapi 4.0.0-beta.0

package/lib/commands/configurationRestore.js

@@ -0,0 +1,169 @@
+'use strict';
+
+const fs = require('fs');
+const _ = require('lodash');
+const strapi = require('../index');
+
+/**
+ * Will restore configurations. It reads from a file or stdin
+ * @param {string} file filepath to use as input
+ * @param {string} strategy import strategy. one of (replace, merge, keep, default: replace)
+ */
+module.exports = async function({ file: filePath, strategy = 'replace' }) {
+  const input = filePath ? fs.readFileSync(filePath) : await readStdin(process.stdin);
+
+  const app = await strapi().load();
+
+  let dataToImport;
+  try {
+    dataToImport = JSON.parse(input);
+  } catch (error) {
+    throw new Error(`Invalid input data: ${error.message}. Expected a valid JSON array.`);
+  }
+
+  if (!Array.isArray(dataToImport)) {
+    throw new Error(`Invalid input data. Expected a valid JSON array.`);
+  }
+
+  const importer = createImporter(app.db, strategy);
+
+  for (const config of dataToImport) {
+    await importer.import(config);
+  }
+
+  console.log(
+    `Successfully imported configuration with ${strategy} strategy. Statistics: ${importer.printStatistics()}.`
+  );
+
+  process.exit(0);
+};
+
+const readStdin = () => {
+  const { stdin } = process;
+  let result = '';
+
+  if (stdin.isTTY) return Promise.resolve(result);
+
+  return new Promise((resolve, reject) => {
+    stdin.setEncoding('utf8');
+    stdin.on('readable', () => {
+      let chunk;
+      while ((chunk = stdin.read())) {
+        result += chunk;
+      }
+    });
+
+    stdin.on('end', () => {
+      resolve(result);
+    });
+
+    stdin.on('error', reject);
+  });
+};
+
+const createImporter = (db, strategy) => {
+  switch (strategy) {
+    case 'replace':
+      return createReplaceImporter(db);
+    case 'merge':
+      return createMergeImporter(db);
+    case 'keep':
+      return createKeepImporter(db);
+    default:
+      throw new Error(`No importer available for strategy "${strategy}"`);
+  }
+};
+
+/**
+ * Replace importer. Will replace the keys that already exist and create the new ones
+ * @param {Object} db - DatabaseManager instance
+ */
+const createReplaceImporter = db => {
+  const stats = {
+    created: 0,
+    replaced: 0,
+  };
+
+  return {
+    printStatistics() {
+      return `${stats.created} created, ${stats.replaced} replaced`;
+    },
+
+    async import(conf) {
+      const matching = await db.query('strapi::core-store').count({ where: { key: conf.key } });
+      if (matching > 0) {
+        stats.replaced += 1;
+        await db.query('strapi::core-store').update({
+          where: { key: conf.key },
+          data: conf,
+        });
+      } else {
+        stats.created += 1;
+        await db.query('strapi::core-store').create({ data: conf });
+      }
+    },
+  };
+};
+
+/**
+ * Merge importer. Will merge the keys that already exist with their new value and create the new ones
+ * @param {Object} db - DatabaseManager instance
+ */
+const createMergeImporter = db => {
+  const stats = {
+    created: 0,
+    merged: 0,
+  };
+
+  return {
+    printStatistics() {
+      return `${stats.created} created, ${stats.merged} merged`;
+    },
+
+    async import(conf) {
+      const existingConf = await db
+        .query('strapi::core-store')
+        .findOne({ where: { key: conf.key } });
+
+      if (existingConf) {
+        stats.merged += 1;
+        await db.query('strapi::core-store').update({
+          where: { key: conf.key },
+          data: _.merge(existingConf, conf),
+        });
+      } else {
+        stats.created += 1;
+        await db.query('strapi::core-store').create({ data: conf });
+      }
+    },
+  };
+};
+
+/**
+ * Merge importer. Will keep the keys that already exist without changing them and create the new ones
+ * @param {Object} db - DatabaseManager instance
+ */
+const createKeepImporter = db => {
+  const stats = {
+    created: 0,
+    untouched: 0,
+  };
+
+  return {
+    printStatistics() {
+      return `${stats.created} created, ${stats.untouched} untouched`;
+    },
+
+    async import(conf) {
+      const matching = await db.query('strapi::core-store').count({ where: { key: conf.key } });
+      if (matching > 0) {
+        stats.untouched += 1;
+        // if configuration already exists do not overwrite it
+        return;
+      }
+
+      stats.created += 1;
+      await db.query('strapi::core-store').create({ data: conf });
+    },
+  };
+};

package/lib/commands/console.js

@@ -0,0 +1,26 @@
+'use strict';
+
+const REPL = require('repl');
+const strapi = require('../index');
+
+/**
+ * `$ strapi console`
+ */
+module.exports = () => {
+  // Now load up the Strapi framework for real.
+  const app = strapi();
+
+  app.start().then(() => {
+    const repl = REPL.start(app.config.info.name + ' > ' || 'strapi > '); // eslint-disable-line prefer-template
+
+    repl.on('exit', function(err) {
+      if (err) {
+        app.log.error(err);
+        process.exit(1);
+      }
+
+      app.server.destroy();
+      process.exit(0);
+    });
+  });
+};

package/lib/commands/develop.js

@@ -0,0 +1,157 @@
+'use strict';
+
+const path = require('path');
+const cluster = require('cluster');
+const fs = require('fs-extra');
+const chokidar = require('chokidar');
+const execa = require('execa');
+const { getOr } = require('lodash/fp');
+
+const { createLogger } = require('@strapi/logger');
+const loadConfiguration = require('../core/app-configuration');
+const strapi = require('../index');
+
+/**
+ * `$ strapi develop`
+ *
+ */
+module.exports = async function({ build, watchAdmin, polling, browser }) {
+  const dir = process.cwd();
+  const config = loadConfiguration(dir);
+  const logger = createLogger(config.logger, {});
+
+  const adminWatchIgnoreFiles = getOr([], 'server.admin.watchIgnoreFiles')(config);
+  const serveAdminPanel = getOr(true, 'server.admin.serveAdminPanel')(config);
+
+  const buildExists = fs.existsSync(path.join(dir, 'build'));
+  // Don't run the build process if the admin is in watch mode
+  if (build && !watchAdmin && serveAdminPanel && !buildExists) {
+    try {
+      execa.sync('npm run -s build -- --no-optimization', {
+        stdio: 'inherit',
+        shell: true,
+      });
+    } catch (err) {
+      process.exit(1);
+    }
+  }
+
+  try {
+    if (cluster.isMaster) {
+      if (watchAdmin) {
+        try {
+          execa('npm', ['run', '-s', 'strapi', 'watch-admin', '--', '--browser', browser], {
+            stdio: 'inherit',
+          });
+        } catch (err) {
+          process.exit(1);
+        }
+      }
+
+      cluster.on('message', (worker, message) => {
+        switch (message) {
+          case 'reload':
+            logger.info('The server is restarting\n');
+            worker.send('isKilled');
+            break;
+          case 'kill':
+            worker.kill();
+            cluster.fork();
+            break;
+          case 'stop':
+            worker.kill();
+            process.exit(1);
+          default:
+            return;
+        }
+      });
+
+      cluster.fork();
+    }
+
+    if (cluster.isWorker) {
+      const strapiInstance = strapi({
+        dir,
+        autoReload: true,
+        serveAdminPanel: watchAdmin ? false : true,
+      });
+
+      watchFileChanges({
+        dir,
+        strapiInstance,
+        watchIgnoreFiles: adminWatchIgnoreFiles,
+        polling,
+      });
+
+      process.on('message', async message => {
+        switch (message) {
+          case 'isKilled':
+            await strapiInstance.server.destroy();
+            process.send('kill');
+            break;
+          default:
+          // Do nothing.
+        }
+      });
+
+      return strapiInstance.start();
+    }
+  } catch (e) {
+    logger.error(e);
+    process.exit(1);
+  }
+};
+
+/**
+ * Init file watching to auto restart strapi app
+ * @param {Object} options - Options object
+ * @param {string} options.dir - This is the path where the app is located, the watcher will watch the files under this folder
+ * @param {Strapi} options.strapi - Strapi instance
+ * @param {array} options.watchIgnoreFiles - Array of custom file paths that should not be watched
+ */
+function watchFileChanges({ dir, strapiInstance, watchIgnoreFiles, polling }) {
+  const restart = () => {
+    if (strapiInstance.reload.isWatching && !strapiInstance.reload.isReloading) {
+      strapiInstance.reload.isReloading = true;
+      strapiInstance.reload();
+    }
+  };
+
+  const watcher = chokidar.watch(dir, {
+    ignoreInitial: true,
+    usePolling: polling,
+    ignored: [
+      /(^|[/\\])\../, // dot files
+      /tmp/,
+      '**/admin',
+      '**/admin/**',
+      'src/extensions/**/admin',
+      'src/extensions/**/admin/**',
+      '**/documentation',
+      '**/documentation/**',
+      '**/node_modules',
+      '**/node_modules/**',
+      '**/plugins.json',
+      '**/index.html',
+      '**/public',
+      '**/public/**',
+      '**/*.db*',
+      '**/exports/**',
+      ...watchIgnoreFiles,
+    ],
+  });
+
+  watcher
+    .on('add', path => {
+      strapiInstance.log.info(`File created: ${path}`);
+      restart();
+    })
+    .on('change', path => {
+      strapiInstance.log.info(`File changed: ${path}`);
+      restart();
+    })
+    .on('unlink', path => {
+      strapiInstance.log.info(`File deleted: ${path}`);
+      restart();
+    });
+}

package/lib/commands/generate-template.js

@@ -0,0 +1,97 @@
+'use strict';
+
+const { resolve, join, basename } = require('path');
+const fse = require('fs-extra');
+const chalk = require('chalk');
+const inquirer = require('inquirer');
+
+// All directories that a template could need
+const TEMPLATE_CONTENT = ['api', 'components', 'config/functions/bootstrap.js', 'data'];
+
+/**
+ *
+ * @param {string} templatePath Absolute path to template directory
+ * @param {string} rootBase Name of the root directory
+ */
+async function copyContent(templatePath, rootBase) {
+  for (const item of TEMPLATE_CONTENT) {
+    try {
+      const pathToCopy = join(process.cwd(), item);
+
+      if (!(await fse.pathExists(pathToCopy))) {
+        continue;
+      }
+
+      await fse.copy(pathToCopy, join(templatePath, item));
+      const currentProjectBase = basename(process.cwd());
+      console.log(
+        `${chalk.green(
+          'success'
+        )}: copy ${currentProjectBase}/${item} => ${rootBase}/template/${item}`
+      );
+    } catch (error) {
+      console.error(`${chalk.red('error')}: ${error.message}`);
+    }
+  }
+}
+
+/**
+ *
+ * @param {string} rootPath Absolute path to the root directory
+ */
+async function writeTemplateJson(rootPath) {
+  try {
+    await fse.writeJSON(join(rootPath, 'template.json'), {});
+    console.log(`${chalk.green('success')}: create JSON config file`);
+  } catch (error) {
+    console.error(`${chalk.red('error')}: ${error.message}`);
+  }
+}
+
+/**
+ *
+ * @param {string} rootPath Absolute path to the root directory
+ * @returns boolean
+ */
+async function templateConfigExists(rootPath) {
+  const jsonConfig = await fse.pathExists(join(rootPath, 'template.json'));
+  const functionConfig = await fse.pathExists(join(rootPath, 'template.js'));
+
+  return jsonConfig || functionConfig;
+}
+
+module.exports = async function generateTemplate(directory) {
+  const rootPath = resolve(directory);
+
+  // Get path to template directory: <rootPath>/template
+  const templatePath = join(rootPath, 'template');
+
+  // Check if the template directory exists
+  const exists = await fse.pathExists(templatePath);
+  const rootBase = basename(rootPath);
+
+  if (exists) {
+    // Confirm the user wants to replace the existing template
+    const inquiry = await inquirer.prompt({
+      type: 'confirm',
+      name: 'confirm',
+      message: `${chalk.yellow(rootBase)} already exists.  Do you want to replace it?`,
+    });
+
+    if (!inquiry.confirm) {
+      process.exit(0);
+    }
+  }
+
+  // Create or replace root directory with <roothPath>/template
+  await fse.ensureDir(templatePath);
+  // Copy content to /template
+  await copyContent(templatePath, rootBase);
+  // Create config file if it doesn't exist
+  const configExists = await templateConfigExists(rootPath);
+  if (!configExists) {
+    await writeTemplateJson(rootPath);
+  }
+
+  console.log(`${chalk.green('success')}: generated template at ${chalk.yellow(rootPath)}`);
+};

package/lib/commands/install.js

@@ -0,0 +1,48 @@
+'use strict';
+
+const { join } = require('path');
+const { existsSync } = require('fs-extra');
+const ora = require('ora');
+const execa = require('execa');
+const findPackagePath = require('../load/package-path');
+
+module.exports = async plugins => {
+  const loader = ora();
+  const dir = process.cwd();
+
+  const version = require(join(dir, 'package.json')).dependencies['@strapi/strapi'];
+
+  const pluginArgs = plugins.map(name => `@strapi/plugin-${name}@${version}`);
+
+  try {
+    loader.start(`Installing dependencies`);
+
+    const useYarn = existsSync(join(dir, 'yarn.lock'));
+    if (useYarn) {
+      await execa('yarn', ['add', ...pluginArgs]);
+    } else {
+      await execa('npm', ['install', '--save', ...pluginArgs]);
+    }
+
+    loader.succeed();
+
+    // check if rebuild is necessary
+    let shouldRebuild = false;
+    for (let name of plugins) {
+      let pkgPath = findPackagePath(`@strapi/plugin-${name}`);
+      if (existsSync(join(pkgPath, 'admin', 'src', 'index.js'))) {
+        shouldRebuild = true;
+      }
+    }
+
+    if (shouldRebuild) {
+      loader.start(`Rebuilding admin UI`);
+      await execa('npm', ['run', 'build']);
+      loader.succeed();
+    }
+  } catch (err) {
+    loader.clear();
+    console.error(err.message);
+    process.exit(1);
+  }
+};

package/lib/commands/new.js

@@ -0,0 +1,11 @@
+'use strict';
+
+/**
+ * `$ strapi new`
+ *
+ * Generate a new Strapi application.
+ */
+
+module.exports = function(...args) {
+  return require('@strapi/generate-new')(...args);
+};

package/lib/commands/start.js

@@ -0,0 +1,8 @@
+'use strict';
+
+const strapi = require('../index');
+
+/**
+ * `$ strapi start`
+ */
+module.exports = () => strapi().start();

package/lib/commands/uninstall.js

@@ -0,0 +1,68 @@
+'use strict';
+
+const { join } = require('path');
+const { existsSync, removeSync } = require('fs-extra');
+const ora = require('ora');
+const execa = require('execa');
+const inquirer = require('inquirer');
+const findPackagePath = require('../load/package-path');
+
+module.exports = async (plugins, { deleteFiles }) => {
+  const answers = await inquirer.prompt([
+    {
+      type: 'confirm',
+      name: 'deleteFiles',
+      message: `Do you want to delete the plugin generated files in the extensions folder ?`,
+      default: true,
+      when: !deleteFiles,
+    },
+  ]);
+
+  const loader = ora();
+  const dir = process.cwd();
+
+  const pluginArgs = plugins.map(name => `@strapi/plugin-${name}`);
+
+  try {
+    // verify should rebuild before removing the pacakge
+    let shouldRebuild = false;
+    for (let name of plugins) {
+      let pkgPath = findPackagePath(`@strapi/plugin-${name}`);
+      if (existsSync(join(pkgPath, 'admin', 'src', 'index.js'))) {
+        shouldRebuild = true;
+      }
+    }
+
+    loader.start(`Uninstalling dependencies`);
+
+    const useYarn = existsSync(join(dir, 'yarn.lock'));
+    if (useYarn) {
+      await execa('yarn', ['remove', ...pluginArgs]);
+    } else {
+      await execa('npm', ['remove', ...pluginArgs]);
+    }
+
+    loader.succeed();
+
+    if (deleteFiles === true || answers.deleteFiles === true) {
+      loader.start('Deleting old files');
+      for (let name of plugins) {
+        const pluginDir = join(dir, 'extensions', name);
+        if (existsSync(pluginDir)) {
+          removeSync(pluginDir);
+        }
+      }
+      loader.succeed();
+    }
+
+    if (shouldRebuild) {
+      loader.start(`Rebuilding admin UI`);
+      await execa('npm', ['run', 'build']);
+      loader.succeed();
+    }
+  } catch (err) {
+    loader.clear();
+    console.error(err.message);
+    process.exit(1);
+  }
+};

package/lib/commands/watchAdmin.js

@@ -0,0 +1,45 @@
+'use strict';
+
+const strapiAdmin = require('@strapi/admin');
+const { getConfigUrls, getAbsoluteServerUrl } = require('@strapi/utils');
+
+const ee = require('../utils/ee');
+const addSlash = require('../utils/addSlash');
+const strapi = require('../index');
+const getEnabledPlugins = require('../core/loaders/plugins/get-enabled-plugins');
+
+module.exports = async function({ browser }) {
+  const dir = process.cwd();
+
+  const strapiInstance = strapi({
+    dir,
+    autoReload: true,
+    serveAdminPanel: false,
+  });
+
+  const plugins = await getEnabledPlugins(strapiInstance);
+
+  const { adminPath } = getConfigUrls(strapiInstance.config.get('server'), true);
+
+  const adminPort = strapiInstance.config.get('server.admin.port', 8000);
+  const adminHost = strapiInstance.config.get('server.admin.host', 'localhost');
+  const adminWatchIgnoreFiles = strapiInstance.config.get('server.admin.watchIgnoreFiles', []);
+
+  const backendURL = getAbsoluteServerUrl(strapiInstance.config, true);
+
+  ee({ dir });
+
+  strapiAdmin.watchAdmin({
+    dir,
+    plugins,
+    port: adminPort,
+    host: adminHost,
+    browser,
+    options: {
+      backend: backendURL,
+      adminPath: addSlash(adminPath),
+      watchIgnoreFiles: adminWatchIgnoreFiles,
+      features: ee.isEE ? ee.features.getEnabled() : [],
+    },
+  });
+};

package/lib/container.js

@@ -0,0 +1,45 @@
+'use strict';
+
+const createContainer = strapi => {
+  const registered = new Map();
+  const resolved = new Map();
+
+  return {
+    register(name, resolver) {
+      if (registered.has(name)) {
+        throw new Error(`Cannot register already registered service ${name}`);
+      }
+
+      registered.set(name, resolver);
+      return this;
+    },
+
+    get(name, args) {
+      // TODO: handle singleton vs reinstanciation everytime
+      if (resolved.has(name)) {
+        return resolved.get(name);
+      }
+
+      if (registered.has(name)) {
+        const resolver = registered.get(name);
+
+        if (typeof resolver === 'function') {
+          resolved.set(name, resolver({ strapi }, args));
+        } else {
+          resolved.set(name, resolver);
+        }
+
+        return resolved.get(name);
+      }
+
+      throw new Error(`Could not resolve service ${name}`);
+    },
+
+    // TODO: implement
+    extend() {},
+  };
+};
+
+module.exports = {
+  createContainer,
+};

package/lib/core/app-configuration/config-loader.js

@@ -0,0 +1,20 @@
+'use strict';
+
+const path = require('path');
+const fs = require('fs');
+const loadFile = require('./load-config-file');
+
+module.exports = dir => {
+  if (!fs.existsSync(dir)) return {};
+
+  return fs
+    .readdirSync(dir, { withFileTypes: true })
+    .filter(file => file.isFile())
+    .reduce((acc, file) => {
+      const key = path.basename(file.name, path.extname(file.name));
+
+      acc[key] = loadFile(path.resolve(dir, file.name));
+
+      return acc;
+    }, {});
+};