@strapi/strapi 4.0.0-next.6 → 4.0.0

package/lib/Strapi.js

@@ -1,68 +1,158 @@
 '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/load-modules');
 const utils = require('./utils');
-const bootstrap = require('./core/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');
+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 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 = {}) {
+    destroyOnSignal(this);
+    this.dirs = utils.getDirs(opts.dir || process.cwd());
+    const appConfig = loadConfiguration(this.dirs.root, opts);
     this.container = createContainer(this);
-
-    this.dir = opts.dir || process.cwd();
-    this.config = loadConfiguration(this.dir, opts);
-
-    this.reload = this.reload();
-
-    // Expose `koa`.
-    this.app = new Koa();
-    this.router = new Router();
-
-    this.server = createHTTPServer(this, this.app);
-
-    this.app.proxy = this.config.get('server.proxy');
-
-    // Logger.
-    const loggerUserConfiguration = this.config.get('logger', {});
-    this.log = createLogger(loggerUserConfiguration);
+    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.server = createServer(this);
 
-    // internal services.
     this.fs = createStrapiFs(this);
     this.eventHub = createEventHub();
     this.startupLogger = createStartupLogger(this);
+    this.log = createLogger(this.config.get('logger', {}));
+    this.cron = createCronService();
+    this.telemetry = createTelemetry(this);
 
     createUpdateNotifier(this).notify();
   }
 
+  get config() {
+    return this.container.get('config');
+  }
+
   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);
+  }
+
+  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() {
@@ -71,31 +161,18 @@ class Strapi {
         await this.load();
       }
 
-      this.app.use(this.router.routes()).use(this.router.allowedMethods());
-
-      // Launch server.
       await this.listen();
 
       return this;
     } catch (error) {
-      return this.stopWithError(error.message);
+      return this.stopWithError(error);
     }
   }
 
   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();
 
@@ -104,6 +181,9 @@ class Strapi {
     }
 
     this.telemetry.destroy();
+    this.cron.destroy();
+
+    process.removeAllListeners();
 
     delete global.strapi;
   }
@@ -123,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);
     }
   }
@@ -181,9 +261,9 @@ class Strapi {
   }
 
   stop(exitCode = 1) {
-    this.server.destroy();
+    this.destroy();
 
-    if (this.config.autoReload) {
+    if (this.config.get('autoReload')) {
       process.send('stop');
     }
 
@@ -191,35 +271,54 @@ class Strapi {
     process.exit(exitCode);
   }
 
-  loadAdmin() {
-    this.admin = require('@strapi/admin/strapi-server');
+  async loadAdmin() {
+    await loaders.loadAdmin(this);
+  }
 
-    // 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 loadPlugins() {
+    await loaders.loadPlugins(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 loadPolicies() {
+    await loaders.loadPolicies(this);
+  }
+
+  async loadAPIs() {
+    await loaders.loadAPIs(this);
+  }
+
+  async loadComponents() {
+    this.components = await loaders.loadComponents(this);
+  }
 
-    const modules = await loadModules(this);
+  async loadMiddlewares() {
+    await loaders.loadMiddlewares(this);
+  }
+
+  async loadApp() {
+    this.app = await loaders.loadSrcIndex(this);
+  }
 
-    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.plugins = modules.plugins;
-    this.middleware = modules.middlewares;
-    this.hook = modules.hook;
+    this.hook('strapi::content-types.beforeSync').register(draftAndPublishSync.disable);
+    this.hook('strapi::content-types.afterSync').register(draftAndPublishSync.enable);
+  }
 
-    await bootstrap(this);
+  async register() {
+    await Promise.all([
+      this.loadApp(),
+      this.loadPlugins(),
+      this.loadAdmin(),
+      this.loadAPIs(),
+      this.loadComponents(),
+      this.loadMiddlewares(),
+      this.loadPolicies(),
+    ]);
+
+    await bootstrap({ strapi: this });
 
     // init webhook runner
     this.webhookRunner = createWebhookRunner({
@@ -228,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,
@@ -242,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,
@@ -262,14 +360,57 @@ class Strapi {
       entityValidator: this.entityValidator,
     });
 
-    this.telemetry = createTelemetry(this);
+    const cronTasks = this.config.get('server.cron.tasks', {});
+    this.cron.add(cronTasks);
+
+    this.telemetry.bootstrap();
 
-    // Initialize middlewares.
-    await initializeMiddlewares.call(this);
+    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;
   }
 
@@ -291,8 +432,7 @@ class Strapi {
         return;
       }
 
-      if (this.config.autoReload) {
-        this.server.destroy();
+      if (this.config.get('autoReload')) {
         process.send('reload');
       }
     };
@@ -300,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;
       },
     });
@@ -319,39 +459,20 @@ class Strapi {
   }
 
   async runLifecyclesFunctions(lifecycleName) {
-    const execLifecycle = async fn => {
-      if (!fn) {
-        return;
-      }
-
-      return fn();
-    };
-
-    const configPath = `functions.${lifecycleName}`;
-
     // plugins
-    await Promise.all(
-      Object.keys(this.plugins).map(plugin => {
-        const pluginFunc = _.get(this.plugins[plugin], `config.${configPath}`);
-
-        return execLifecycle(pluginFunc).catch(err => {
-          strapi.log.error(`${lifecycleName} function in plugin "${plugin}" failed`);
-          console.error(err);
-          strapi.stop();
-        });
-      })
-    );
+    await this.container.get('modules')[lifecycleName]();
 
     // user
-    await execLifecycle(_.get(this.config, 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) {
@@ -361,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 }) => {
   const dir = process.cwd();
-  const config = loadConfiguration(dir);
 
-  const { serverUrl, adminPath } = getConfigUrls(config.get('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 });
@@ -28,6 +37,7 @@ module.exports = async ({ clean, optimization }) => {
   return strapiAdmin
     .build({
       dir,
+      plugins,
       // front end build env is always production for now
       env: 'production',
       optimize: optimization,

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/develop.js

@@ -5,6 +5,7 @@ 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');
@@ -17,17 +18,18 @@ const strapi = require('../index');
 module.exports = async function({ build, watchAdmin, polling, browser }) {
   const dir = process.cwd();
   const config = loadConfiguration(dir);
-  const logger = createLogger(config.get('logger', {}));
+  const logger = createLogger(config.logger, {});
 
-  const adminWatchIgnoreFiles = config.get('server.admin.watchIgnoreFiles', []);
-  const serveAdminPanel = config.get('server.admin.serveAdminPanel', true);
+  const adminWatchIgnoreFiles = getOr([], 'admin.watchIgnoreFiles')(config);
+  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 {
-      execa.shellSync('npm run -s build -- --no-optimization', {
+      execa.sync('npm run -s build -- --no-optimization', {
         stdio: 'inherit',
+        shell: true,
       });
     } catch (err) {
       process.exit(1);
@@ -50,14 +52,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;
@@ -81,13 +81,12 @@ module.exports = async function({ build, watchAdmin, polling, browser }) {
         polling,
       });
 
-      process.on('message', message => {
+      process.on('message', async message => {
         switch (message) {
-          case 'isKilled':
-            strapiInstance.server.destroy(() => {
-              process.send('kill');
-            });
-            break;
+          case 'kill':
+            await strapiInstance.destroy();
+            process.send('killed');
+            process.exit();
           default:
           // Do nothing.
         }
@@ -122,10 +121,10 @@ function watchFileChanges({ dir, strapiInstance, watchIgnoreFiles, polling }) {
     ignored: [
       /(^|[/\\])\../, // dot files
       /tmp/,
-      '**/admin',
-      '**/admin/**',
-      'extensions/**/admin',
-      'extensions/**/admin/**',
+      'admin',
+      'admin/**',
+      'src/extensions/**/admin',
+      'src/extensions/**/admin/**',
       '**/documentation',
       '**/documentation/**',
       '**/node_modules',