@strapi/strapi 4.0.0-next.7 → 4.0.1

package/lib/Strapi.js

@@ -1,27 +1,26 @@
 'use strict';
 
-const Koa = require('koa');
-const Router = require('koa-router');
 const _ = require('lodash');
+const { isFunction } = require('lodash/fp');
 const { createLogger } = require('@strapi/logger');
 const { Database } = require('@strapi/database');
+const { createAsyncParallelHook } = require('@strapi/utils').hooks;
 
 const loadConfiguration = require('./core/app-configuration');
 
-const { createHTTPServer } = require('./server');
 const { createContainer } = require('./container');
-const loadModules = require('./core/loaders/load-modules');
 const utils = require('./utils');
-const bootstrap = require('./core/loaders/bootstrap');
-const initializeMiddlewares = require('./middlewares');
-const createStrapiFs = require('./core/fs');
+const createStrapiFs = require('./services/fs');
 const createEventHub = require('./services/event-hub');
+const { createServer } = require('./services/server');
 const createWebhookRunner = require('./services/webhook-runner');
 const { webhookModel, createWebhookStore } = require('./services/webhook-store');
 const { createCoreStore, coreStoreModel } = require('./services/core-store');
 const createEntityService = require('./services/entity-service');
+const createCronService = require('./services/cron');
 const entityValidator = require('./services/entity-validator');
 const createTelemetry = require('./services/metrics');
+const createAuth = require('./services/auth');
 const createUpdateNotifier = require('./utils/update-notifier');
 const createStartupLogger = require('./utils/startup-logger');
 const ee = require('./utils/ee');
@@ -29,43 +28,53 @@ const contentTypesRegistry = require('./core/registries/content-types');
 const servicesRegistry = require('./core/registries/services');
 const policiesRegistry = require('./core/registries/policies');
 const middlewaresRegistry = require('./core/registries/middlewares');
+const hooksRegistry = require('./core/registries/hooks');
 const controllersRegistry = require('./core/registries/controllers');
 const modulesRegistry = require('./core/registries/modules');
 const pluginsRegistry = require('./core/registries/plugins');
 const createConfigProvider = require('./core/registries/config');
-const loadPlugins = require('./core/load-plugins');
-// const { nameToSlug } = require('../../utils/lib');
+const apisRegistry = require('./core/registries/apis');
+const bootstrap = require('./core/bootstrap');
+const loaders = require('./core/loaders');
+const { destroyOnSignal } = require('./utils/signals');
+
+// TODO: move somewhere else
+const draftAndPublishSync = require('./migrations/draft-publish');
 
 const LIFECYCLES = {
   REGISTER: 'register',
   BOOTSTRAP: 'bootstrap',
+  DESTROY: 'destroy',
 };
 
 class Strapi {
   constructor(opts = {}) {
-    this.dir = opts.dir || process.cwd();
-    const appConfig = loadConfiguration(this.dir, opts);
+    destroyOnSignal(this);
+    this.dirs = utils.getDirs(opts.dir || process.cwd());
+    const appConfig = loadConfiguration(this.dirs.root, opts);
     this.container = createContainer(this);
     this.container.register('config', createConfigProvider(appConfig));
     this.container.register('content-types', contentTypesRegistry(this));
     this.container.register('services', servicesRegistry(this));
     this.container.register('policies', policiesRegistry(this));
     this.container.register('middlewares', middlewaresRegistry(this));
+    this.container.register('hooks', hooksRegistry(this));
     this.container.register('controllers', controllersRegistry(this));
     this.container.register('modules', modulesRegistry(this));
     this.container.register('plugins', pluginsRegistry(this));
+    this.container.register('apis', apisRegistry(this));
+    this.container.register('auth', createAuth(this));
 
     this.isLoaded = false;
     this.reload = this.reload();
-    this.app = new Koa();
-    this.router = new Router();
-    this.server = createHTTPServer(this, this.app);
-    this.contentTypes = {}; // to remove V3
+    this.server = createServer(this);
+
     this.fs = createStrapiFs(this);
     this.eventHub = createEventHub();
     this.startupLogger = createStartupLogger(this);
-    this.app.proxy = this.config.get('server.proxy');
     this.log = createLogger(this.config.get('logger', {}));
+    this.cron = createCronService();
+    this.telemetry = createTelemetry(this);
 
     createUpdateNotifier(this).notify();
   }
@@ -75,30 +84,83 @@ class Strapi {
   }
 
   get EE() {
-    return ee({ dir: this.dir, logger: this.log });
+    return ee({ dir: this.dirs.root, logger: this.log });
+  }
+
+  get services() {
+    return this.container.get('services').getAll();
   }
 
   service(uid) {
     return this.container.get('services').get(uid);
   }
 
-  plugin(name) {
-    return this.container.get('plugins').get(name);
+  get controllers() {
+    return this.container.get('controllers').getAll();
+  }
+
+  controller(uid) {
+    return this.container.get('controllers').get(uid);
+  }
+
+  get contentTypes() {
+    return this.container.get('content-types').getAll();
+  }
+
+  contentType(name) {
+    return this.container.get('content-types').get(name);
+  }
+
+  get policies() {
+    return this.container.get('policies').getAll();
+  }
+
+  policy(name) {
+    return this.container.get('policies').get(name);
+  }
+
+  get middlewares() {
+    return this.container.get('middlewares').getAll();
+  }
+
+  middleware(name) {
+    return this.container.get('middlewares').get(name);
   }
 
   get plugins() {
     return this.container.get('plugins').getAll();
   }
 
+  plugin(name) {
+    return this.container.get('plugins').get(name);
+  }
+
+  get hooks() {
+    return this.container.get('hooks').getAll();
+  }
+
+  hook(name) {
+    return this.container.get('hooks').get(name);
+  }
+
+  // api(name) {
+  //   return this.container.get('apis').get(name);
+  // }
+
+  get api() {
+    return this.container.get('apis').getAll();
+  }
+
+  get auth() {
+    return this.container.get('auth');
+  }
+
   async start() {
     try {
       if (!this.isLoaded) {
         await this.load();
       }
 
-      this.app.use(this.router.routes()).use(this.router.allowedMethods());
-
-      // Launch server.
       await this.listen();
 
       return this;
@@ -110,17 +172,7 @@ class Strapi {
   async destroy() {
     await this.server.destroy();
 
-    await Promise.all(
-      Object.values(this.plugins).map(plugin => {
-        if (_.has(plugin, 'destroy') && typeof plugin.destroy === 'function') {
-          return plugin.destroy();
-        }
-      })
-    );
-
-    if (_.has(this, 'admin')) {
-      await this.admin.destroy();
-    }
+    await this.runLifecyclesFunctions(LIFECYCLES.DESTROY);
 
     this.eventHub.removeAllListeners();
 
@@ -129,6 +181,9 @@ class Strapi {
     }
 
     this.telemetry.destroy();
+    this.cron.destroy();
+
+    process.removeAllListeners();
 
     delete global.strapi;
   }
@@ -148,10 +203,10 @@ class Strapi {
 
   async openAdmin({ isInitialized }) {
     const shouldOpenAdmin =
-      this.config.environment === 'development' &&
-      this.config.get('server.admin.autoOpen', true) !== false;
+      this.config.get('environment') === 'development' &&
+      this.config.get('admin.autoOpen', true) !== false;
 
-    if (shouldOpenAdmin || !isInitialized) {
+    if (shouldOpenAdmin && !isInitialized) {
       await utils.openBrowser(this.config);
     }
   }
@@ -206,7 +261,7 @@ class Strapi {
   }
 
   stop(exitCode = 1) {
-    this.server.destroy();
+    this.destroy();
 
     if (this.config.get('autoReload')) {
       process.send('stop');
@@ -216,45 +271,54 @@ class Strapi {
     process.exit(exitCode);
   }
 
-  loadAdmin() {
-    this.admin = require('@strapi/admin/strapi-server');
-
-    // TODO: rename into just admin and ./config/admin.js
-    const userAdminConfig = strapi.config.get('server.admin');
-    this.config.set('server.admin', _.merge(this.admin.config, userAdminConfig));
+  async loadAdmin() {
+    await loaders.loadAdmin(this);
   }
 
   async loadPlugins() {
-    const loadedPlugins = await loadPlugins(this);
+    await loaders.loadPlugins(this);
+  }
 
-    for (const pluginName in loadedPlugins) {
-      this.container.get('plugins').add(pluginName, loadedPlugins[pluginName]);
-    }
+  async loadPolicies() {
+    await loaders.loadPolicies(this);
   }
 
-  async load() {
-    this.app.use(async (ctx, next) => {
-      if (ctx.request.url === '/_health' && ['HEAD', 'GET'].includes(ctx.request.method)) {
-        ctx.set('strapi', 'You are so French!');
-        ctx.status = 204;
-      } else {
-        await next();
-      }
-    });
+  async loadAPIs() {
+    await loaders.loadAPIs(this);
+  }
+
+  async loadComponents() {
+    this.components = await loaders.loadComponents(this);
+  }
 
-    await this.loadPlugins();
+  async loadMiddlewares() {
+    await loaders.loadMiddlewares(this);
+  }
 
-    const modules = await loadModules(this);
+  async loadApp() {
+    this.app = await loaders.loadSrcIndex(this);
+  }
 
-    await this.loadAdmin();
+  registerInternalHooks() {
+    this.container.get('hooks').set('strapi::content-types.beforeSync', createAsyncParallelHook());
+    this.container.get('hooks').set('strapi::content-types.afterSync', createAsyncParallelHook());
 
-    this.api = modules.api;
-    this.components = modules.components;
+    this.hook('strapi::content-types.beforeSync').register(draftAndPublishSync.disable);
+    this.hook('strapi::content-types.afterSync').register(draftAndPublishSync.enable);
+  }
 
-    this.middleware = modules.middlewares;
-    this.hook = modules.hook;
+  async register() {
+    await Promise.all([
+      this.loadApp(),
+      this.loadPlugins(),
+      this.loadAdmin(),
+      this.loadAPIs(),
+      this.loadComponents(),
+      this.loadMiddlewares(),
+      this.loadPolicies(),
+    ]);
 
-    await bootstrap(this);
+    await bootstrap({ strapi: this });
 
     // init webhook runner
     this.webhookRunner = createWebhookRunner({
@@ -263,8 +327,16 @@ class Strapi {
       configuration: this.config.get('server.webhooks', {}),
     });
 
+    this.registerInternalHooks();
+
+    this.telemetry.register();
+
     await this.runLifecyclesFunctions(LIFECYCLES.REGISTER);
 
+    return this;
+  }
+
+  async bootstrap() {
     const contentTypes = [
       coreStoreModel,
       webhookModel,
@@ -277,19 +349,10 @@ class Strapi {
       models: Database.transformContentTypes(contentTypes),
     });
 
-    await this.db.schema.sync();
-
-    this.store = createCoreStore({
-      environment: this.config.environment,
-      db: this.db,
-    });
-
+    this.store = createCoreStore({ db: this.db });
     this.webhookStore = createWebhookStore({ db: this.db });
 
-    await this.startWebhooks();
-
     this.entityValidator = entityValidator;
-
     this.entityService = createEntityService({
       strapi: this,
       db: this.db,
@@ -297,14 +360,57 @@ class Strapi {
       entityValidator: this.entityValidator,
     });
 
-    this.telemetry = createTelemetry(this);
+    const cronTasks = this.config.get('server.cron.tasks', {});
+    this.cron.add(cronTasks);
 
-    // Initialize middlewares.
-    await initializeMiddlewares.call(this);
+    this.telemetry.bootstrap();
+
+    let oldContentTypes;
+    if (await this.db.getSchemaConnection().hasTable(coreStoreModel.collectionName)) {
+      oldContentTypes = await this.store.get({
+        type: 'strapi',
+        name: 'content_types',
+        key: 'schema',
+      });
+    }
+
+    await this.hook('strapi::content-types.beforeSync').call({
+      oldContentTypes,
+      contentTypes: strapi.contentTypes,
+    });
+
+    await this.db.schema.sync();
+
+    await this.hook('strapi::content-types.afterSync').call({
+      oldContentTypes,
+      contentTypes: strapi.contentTypes,
+    });
+
+    await this.store.set({
+      type: 'strapi',
+      name: 'content_types',
+      key: 'schema',
+      value: strapi.contentTypes,
+    });
+
+    await this.startWebhooks();
+
+    await this.server.initMiddlewares();
+    await this.server.initRouting();
 
     await this.runLifecyclesFunctions(LIFECYCLES.BOOTSTRAP);
 
+    this.cron.start();
+
+    return this;
+  }
+
+  async load() {
+    await this.register();
+    await this.bootstrap();
+
     this.isLoaded = true;
+
     return this;
   }
 
@@ -327,7 +433,6 @@ class Strapi {
       }
 
       if (this.config.get('autoReload')) {
-        this.server.destroy();
         process.send('reload');
       }
     };
@@ -335,14 +440,14 @@ class Strapi {
     Object.defineProperty(reload, 'isWatching', {
       configurable: true,
       enumerable: true,
-      set: value => {
+      set(value) {
         // Special state when the reloader is disabled temporarly (see GraphQL plugin example).
         if (state.isWatching === false && value === true) {
           state.shouldReload += 1;
         }
         state.isWatching = value;
       },
-      get: () => {
+      get() {
         return state.isWatching;
       },
     });
@@ -354,29 +459,20 @@ class Strapi {
   }
 
   async runLifecyclesFunctions(lifecycleName) {
-    const execLifecycle = async fn => {
-      if (!fn) {
-        return;
-      }
-
-      return fn();
-    };
-
-    const configPath = `functions.${lifecycleName}`;
-
     // plugins
     await this.container.get('modules')[lifecycleName]();
 
     // user
-    await execLifecycle(this.config.get(configPath));
+    const userLifecycleFunction = this.app && this.app[lifecycleName];
+    if (isFunction(userLifecycleFunction)) {
+      await userLifecycleFunction({ strapi: this });
+    }
 
     // admin
-    const adminFunc = _.get(this.admin.config, configPath);
-    return execLifecycle(adminFunc).catch(err => {
-      strapi.log.error(`${lifecycleName} function in admin failed`);
-      console.error(err);
-      strapi.stop();
-    });
+    const adminLifecycleFunction = this.admin && this.admin[lifecycleName];
+    if (isFunction(adminLifecycleFunction)) {
+      await adminLifecycleFunction({ strapi: this });
+    }
   }
 
   getModel(uid) {
@@ -386,7 +482,6 @@ class Strapi {
   /**
    * Binds queries with a specific model
    * @param {string} uid
-   * @returns {}
    */
   query(uid) {
     return this.db.query(uid);

package/lib/commands/build.js

@@ -1,23 +1,32 @@
 'use strict';
 const { green } = require('chalk');
 
-// eslint-disable-next-line node/no-extraneous-require
 const strapiAdmin = require('@strapi/admin');
 const { getConfigUrls } = require('@strapi/utils');
-const loadConfiguration = require('../core/app-configuration');
-const ee = require('../utils/ee');
 
+const ee = require('../utils/ee');
 const addSlash = require('../utils/addSlash');
+const strapi = require('../index');
+const getEnabledPlugins = require('../core/loaders/plugins/get-enabled-plugins');
+
 /**
  * `$ strapi build`
  */
-module.exports = async ({ clean, optimization }) => {
+module.exports = async ({ clean, optimization, forceBuild = true }) => {
   const dir = process.cwd();
-  const config = loadConfiguration(dir);
 
-  const { serverUrl, adminPath } = getConfigUrls(config.server, true);
+  const strapiInstance = strapi({
+    dir,
+    autoReload: true,
+    serveAdminPanel: false,
+  });
+
+  const plugins = await getEnabledPlugins(strapiInstance);
+
+  const env = strapiInstance.config.get('environment');
+  const { serverUrl, adminPath } = getConfigUrls(strapiInstance.config, true);
 
-  console.log(`Building your admin UI with ${green(config.environment)} configuration ...`);
+  console.log(`Building your admin UI with ${green(env)} configuration ...`);
 
   if (clean) {
     await strapiAdmin.clean({ dir });
@@ -27,7 +36,9 @@ module.exports = async ({ clean, optimization }) => {
 
   return strapiAdmin
     .build({
+      forceBuild,
       dir,
+      plugins,
       // front end build env is always production for now
       env: 'production',
       optimize: optimization,
@@ -37,7 +48,7 @@ module.exports = async ({ clean, optimization }) => {
       },
     })
     .then(() => {
-      process.exit();
+      console.log('Admin UI built successfully');
     })
     .catch(err => {
       console.error(err);

package/lib/commands/console.js

@@ -10,7 +10,7 @@ module.exports = () => {
   // Now load up the Strapi framework for real.
   const app = strapi();
 
-  app.start(() => {
+  app.start().then(() => {
     const repl = REPL.start(app.config.info.name + ' > ' || 'strapi > '); // eslint-disable-line prefer-template
 
     repl.on('exit', function(err) {

package/lib/commands/content-types/list.js

@@ -0,0 +1,22 @@
+'use strict';
+
+const CLITable = require('cli-table3');
+const chalk = require('chalk');
+
+const strapi = require('../../index');
+
+module.exports = async function() {
+  const app = await strapi().register();
+
+  const list = app.container.get('content-types').keys();
+
+  const infoTable = new CLITable({
+    head: [chalk.blue('Name')],
+  });
+
+  list.forEach(name => infoTable.push([name]));
+
+  console.log(infoTable.toString());
+
+  await app.destroy();
+};

package/lib/commands/controllers/list.js

@@ -0,0 +1,22 @@
+'use strict';
+
+const CLITable = require('cli-table3');
+const chalk = require('chalk');
+
+const strapi = require('../../index');
+
+module.exports = async function() {
+  const app = await strapi().register();
+
+  const list = app.container.get('controllers').keys();
+
+  const infoTable = new CLITable({
+    head: [chalk.blue('Name')],
+  });
+
+  list.forEach(name => infoTable.push([name]));
+
+  console.log(infoTable.toString());
+
+  await app.destroy();
+};

package/lib/commands/develop.js

@@ -10,6 +10,7 @@ const { getOr } = require('lodash/fp');
 const { createLogger } = require('@strapi/logger');
 const loadConfiguration = require('../core/app-configuration');
 const strapi = require('../index');
+const buildAdmin = require('./build');
 
 /**
  * `$ strapi develop`
@@ -20,23 +21,20 @@ module.exports = async function({ build, watchAdmin, polling, browser }) {
   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.shellSync('npm run -s build -- --no-optimization', {
-        stdio: 'inherit',
-      });
-    } catch (err) {
-      process.exit(1);
-    }
-  }
-
   try {
     if (cluster.isMaster) {
+      const serveAdminPanel = getOr(true, '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 {
+          await buildAdmin({ clean: false, optimization: false, forceBuild: false });
+        } catch (err) {
+          process.exit(1);
+        }
+      }
+
       if (watchAdmin) {
         try {
           execa('npm', ['run', '-s', 'strapi', 'watch-admin', '--', '--browser', browser], {
@@ -51,14 +49,12 @@ module.exports = async function({ build, watchAdmin, polling, browser }) {
         switch (message) {
           case 'reload':
             logger.info('The server is restarting\n');
-            worker.send('isKilled');
+            worker.send('kill');
             break;
-          case 'kill':
-            worker.kill();
+          case 'killed':
             cluster.fork();
             break;
           case 'stop':
-            worker.kill();
             process.exit(1);
           default:
             return;
@@ -75,6 +71,7 @@ module.exports = async function({ build, watchAdmin, polling, browser }) {
         serveAdminPanel: watchAdmin ? false : true,
       });
 
+      const adminWatchIgnoreFiles = getOr([], 'admin.watchIgnoreFiles')(config);
       watchFileChanges({
         dir,
         strapiInstance,
@@ -84,10 +81,10 @@ module.exports = async function({ build, watchAdmin, polling, browser }) {
 
       process.on('message', async message => {
         switch (message) {
-          case 'isKilled':
-            await strapiInstance.server.destroy();
-            process.send('kill');
-            break;
+          case 'kill':
+            await strapiInstance.destroy();
+            process.send('killed');
+            process.exit();
           default:
           // Do nothing.
         }
@@ -122,10 +119,8 @@ function watchFileChanges({ dir, strapiInstance, watchIgnoreFiles, polling }) {
     ignored: [
       /(^|[/\\])\../, // dot files
       /tmp/,
-      '**/admin',
-      '**/admin/**',
-      'extensions/**/admin',
-      'extensions/**/admin/**',
+      '**/src/admin/**',
+      '**/src/plugins/**/admin/',
       '**/documentation',
       '**/documentation/**',
       '**/node_modules',