@strapi/strapi 4.0.0-next.11 → 4.0.0-next.15

package/bin/strapi.js

@@ -58,10 +58,7 @@ const getLocalScript = name => (...args) => {
 };
 
 // Initial program setup
-program
-  .storeOptionsAsProperties(false)
-  .passCommandToAction(false)
-  .allowUnknownOption(true);
+program.storeOptionsAsProperties(false).allowUnknownOption(true);
 
 program.helpOption('-h, --help', 'Display help for command');
 program.addHelpCommand('help [command]', 'Display help for command');

package/lib/Strapi.js

@@ -3,6 +3,7 @@
 const _ = require('lodash');
 const { createLogger } = require('@strapi/logger');
 const { Database } = require('@strapi/database');
+const { createAsyncParallelHook } = require('@strapi/utils').hooks;
 
 const loadConfiguration = require('./core/app-configuration');
 
@@ -16,6 +17,7 @@ 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');
@@ -26,6 +28,7 @@ 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');
@@ -34,6 +37,9 @@ const apisRegistry = require('./core/registries/apis');
 const bootstrap = require('./core/bootstrap');
 const loaders = require('./core/loaders');
 
+// TODO: move somewhere else
+const draftAndPublishSync = require('./migrations/draft-publish');
+
 const LIFECYCLES = {
   REGISTER: 'register',
   BOOTSTRAP: 'bootstrap',
@@ -41,14 +47,15 @@ const LIFECYCLES = {
 
 class Strapi {
   constructor(opts = {}) {
-    this.dir = opts.dir || process.cwd();
-    const appConfig = loadConfiguration(this.dir, opts);
+    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));
@@ -63,6 +70,7 @@ class Strapi {
     this.eventHub = createEventHub();
     this.startupLogger = createStartupLogger(this);
     this.log = createLogger(this.config.get('logger', {}));
+    this.cron = createCronService();
 
     createUpdateNotifier(this).notify();
   }
@@ -72,7 +80,7 @@ class Strapi {
   }
 
   get EE() {
-    return ee({ dir: this.dir, logger: this.log });
+    return ee({ dir: this.dirs.root, logger: this.log });
   }
 
   service(uid) {
@@ -107,6 +115,14 @@ class Strapi {
     return this.container.get('plugins').getAll();
   }
 
+  hook(name) {
+    return this.container.get('hooks').get(name);
+  }
+
+  get hooks() {
+    return this.container.get('hooks');
+  }
+
   // api(name) {
   //   return this.container.get('apis').get(name);
   // }
@@ -115,6 +131,10 @@ class Strapi {
     return this.container.get('apis').getAll();
   }
 
+  get auth() {
+    return this.container.get('auth');
+  }
+
   async start() {
     try {
       if (!this.isLoaded) {
@@ -151,6 +171,7 @@ class Strapi {
     }
 
     this.telemetry.destroy();
+    this.cron.destroy();
 
     delete global.strapi;
   }
@@ -173,7 +194,7 @@ class Strapi {
       this.config.get('environment') === 'development' &&
       this.config.get('server.admin.autoOpen', true) !== false;
 
-    if (shouldOpenAdmin || !isInitialized) {
+    if (shouldOpenAdmin && !isInitialized) {
       await utils.openBrowser(this.config);
     }
   }
@@ -262,8 +283,21 @@ class Strapi {
     this.middleware = await loaders.loadMiddlewares(this);
   }
 
+  async loadApp() {
+    this.app = await loaders.loadSrcIndex(this);
+  }
+
+  registerInternalHooks() {
+    this.hooks.set('strapi::content-types.beforeSync', createAsyncParallelHook());
+    this.hooks.set('strapi::content-types.afterSync', createAsyncParallelHook());
+
+    this.hook('strapi::content-types.beforeSync').register(draftAndPublishSync.disable);
+    this.hook('strapi::content-types.afterSync').register(draftAndPublishSync.enable);
+  }
+
   async load() {
     await Promise.all([
+      this.loadApp(),
       this.loadPlugins(),
       this.loadAdmin(),
       this.loadAPIs(),
@@ -281,6 +315,8 @@ class Strapi {
       configuration: this.config.get('server.webhooks', {}),
     });
 
+    this.registerInternalHooks();
+
     await this.runLifecyclesFunctions(LIFECYCLES.REGISTER);
 
     const contentTypes = [
@@ -295,19 +331,10 @@ class Strapi {
       models: Database.transformContentTypes(contentTypes),
     });
 
-    await this.db.schema.sync();
-
-    this.store = createCoreStore({
-      environment: this.config.get('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,
@@ -315,13 +342,48 @@ class Strapi {
       entityValidator: this.entityValidator,
     });
 
+    const cronTasks = this.config.get('server.cron.tasks', {});
+    this.cron.add(cronTasks);
+
     this.telemetry = createTelemetry(this);
 
+    let oldContentTypes;
+    if (await this.db.connection.schema.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();
+
     // Initialize middlewares.
     await initializeMiddlewares(this);
 
     await this.runLifecyclesFunctions(LIFECYCLES.BOOTSTRAP);
 
+    this.cron.start();
+
     this.isLoaded = true;
 
     return this;
@@ -354,14 +416,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;
       },
     });
@@ -373,21 +435,14 @@ class Strapi {
   }
 
   async runLifecyclesFunctions(lifecycleName) {
-    const execLifecycle = async fn => {
-      if (!fn) {
-        return;
-      }
-
-      return fn({ strapi: this });
-    };
-
-    const configPath = `functions.${lifecycleName}`;
-
     // plugins
     await this.container.get('modules')[lifecycleName]();
 
     // user
-    await execLifecycle(this.config.get(configPath));
+    const lifecycleFunction = this.app[lifecycleName];
+    if (lifecycleFunction) {
+      await lifecycleFunction({ strapi: this });
+    }
 
     // admin
     await this.admin[lifecycleName](this);
@@ -400,7 +455,6 @@ class Strapi {
   /**
    * Binds queries with a specific model
    * @param {string} uid
-   * @returns {}
    */
   query(uid) {
     return this.db.query(uid);

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

@@ -27,8 +27,9 @@ module.exports = async function({ build, watchAdmin, polling, browser }) {
   // 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);
@@ -124,8 +125,8 @@ function watchFileChanges({ dir, strapiInstance, watchIgnoreFiles, polling }) {
       /tmp/,
       '**/admin',
       '**/admin/**',
-      'extensions/**/admin',
-      'extensions/**/admin/**',
+      'src/extensions/**/admin',
+      'src/extensions/**/admin/**',
       '**/documentation',
       '**/documentation/**',
       '**/node_modules',

package/lib/core/domain/content-type/index.js

@@ -68,12 +68,10 @@ const createContentType = (uid, definition) => {
   Object.assign(schema.attributes, {
     [CREATED_AT_ATTRIBUTE]: {
       type: 'datetime',
-      default: () => new Date(),
     },
     // TODO: handle on edit set to new date
     [UPDATED_AT_ATTRIBUTE]: {
       type: 'datetime',
-      default: () => new Date(),
     },
   });
 
@@ -110,11 +108,9 @@ const createContentType = (uid, definition) => {
     private: isPrivate,
   };
 
-  return {
-    ...schema,
-    actions: actions,
-    lifecycles: lifecycles,
-  };
+  Object.assign(schema, { actions, lifecycles });
+
+  return schema;
 };
 
 const getGlobalId = (model, modelName, prefix) => {

package/lib/core/domain/module/index.js

@@ -62,8 +62,8 @@ const createModule = (namespace, rawModule, strapi) => {
       strapi.container.get('config').set(uidToPath(namespace), rawModule.config);
     },
     routes: rawModule.routes,
-    config(path) {
-      return strapi.container.get('config').get(`${uidToPath(namespace)}.${path}`);
+    config(path, defaultValue) {
+      return strapi.container.get('config').get(`${uidToPath(namespace)}.${path}`, defaultValue);
     },
     contentType(ctName) {
       return strapi.container.get('content-types').get(`${namespace}.${ctName}`);

package/lib/core/loaders/apis.js

@@ -14,20 +14,18 @@ const DEFAULT_CONTENT_TYPE = {
 };
 
 module.exports = async strapi => {
-  const apisDir = join(strapi.dir, 'api');
-
-  if (!existsSync(apisDir)) {
-    throw new Error(`Missing api folder. Please create one in your app root directory`);
+  if (!existsSync(strapi.dirs.api)) {
+    throw new Error('Missing api folder. Please create one at `./src/api`');
   }
 
-  const apisFDs = await fse.readdir(apisDir, { withFileTypes: true });
+  const apisFDs = await fse.readdir(strapi.dirs.api, { withFileTypes: true });
   const apis = {};
 
   // only load folders
   for (const apiFD of apisFDs) {
     if (apiFD.isDirectory()) {
       const apiName = normalizeName(apiFD.name);
-      const api = await loadAPI(join(apisDir, apiFD.name));
+      const api = await loadAPI(join(strapi.dirs.api, apiFD.name));
 
       apis[apiName] = api;
     }

package/lib/core/loaders/components.js

@@ -6,19 +6,17 @@ const { pathExists } = require('fs-extra');
 const loadFiles = require('../../load/load-files');
 
 module.exports = async strapi => {
-  const componentsDir = join(strapi.dir, 'components');
-
-  if (!(await pathExists(componentsDir))) {
+  if (!(await pathExists(strapi.dirs.components))) {
     return {};
   }
 
-  const map = await loadFiles(componentsDir, '*/*.*(js|json)');
+  const map = await loadFiles(strapi.dirs.components, '*/*.*(js|json)');
 
   return Object.keys(map).reduce((acc, category) => {
     Object.keys(map[category]).forEach(key => {
       const schema = map[category][key];
 
-      const filePath = join(componentsDir, category, schema.__filename__);
+      const filePath = join(strapi.dirs.components, category, schema.__filename__);
 
       if (!schema.collectionName) {
         return strapi.stopWithError(

package/lib/core/loaders/index.js

@@ -1,6 +1,7 @@
 'use strict';
 
 module.exports = {
+  loadSrcIndex: require('./src-index'),
   loadAPIs: require('./apis'),
   loadMiddlewares: require('./middlewares'),
   loadComponents: require('./components'),

package/lib/core/loaders/middlewares.js

@@ -45,7 +45,7 @@ const createLoaders = strapi => {
     loadMiddlewaresInDir(path.resolve(__dirname, '..', '..', 'middlewares'), middlewares);
 
   const loadLocalMiddlewares = (appPath, middlewares) =>
-    loadMiddlewaresInDir(path.resolve(appPath, 'middlewares'), middlewares);
+    loadMiddlewaresInDir(path.resolve(appPath, 'src', 'middlewares'), middlewares);
 
   const loadMiddlewareDependencies = async (packages, middlewares) => {
     for (let packageName of packages) {

package/lib/core/loaders/plugins/get-enabled-plugins.js

@@ -32,7 +32,7 @@ const toDetailedDeclaration = declaration => {
     try {
       pathToPlugin = dirname(require.resolve(declaration.resolve));
     } catch (e) {
-      pathToPlugin = resolve(strapi.dir, declaration.resolve);
+      pathToPlugin = resolve(strapi.dirs.root, declaration.resolve);
 
       if (!existsSync(pathToPlugin) || !statSync(pathToPlugin).isDirectory()) {
         throw new Error(`${declaration.resolve} couldn't be resolved`);
@@ -72,7 +72,7 @@ const getEnabledPlugins = async strapi => {
   }
 
   const declaredPlugins = {};
-  const userPluginConfigPath = join(strapi.dir, 'config', 'plugins.js');
+  const userPluginConfigPath = join(strapi.dirs.config, 'plugins.js');
   const userPluginsConfig = existsSync(userPluginConfigPath)
     ? loadConfigFile(userPluginConfigPath)
     : {};

package/lib/core/loaders/plugins/index.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const { join, resolve } = require('path');
+const { join } = require('path');
 const { existsSync } = require('fs');
 const { defaultsDeep, getOr, get } = require('lodash/fp');
 const { env } = require('@strapi/utils');
@@ -9,12 +9,12 @@ const loadFiles = require('../../../load/load-files');
 const getEnabledPlugins = require('./get-enabled-plugins');
 
 const defaultPlugin = {
-  bootstrap: () => {},
-  destroy: () => {},
-  register: () => {},
+  bootstrap() {},
+  destroy() {},
+  register() {},
   config: {
     default: {},
-    validator: () => {},
+    validator() {},
   },
   routes: [],
   controllers: {},
@@ -25,7 +25,7 @@ const defaultPlugin = {
 };
 
 const applyUserExtension = async plugins => {
-  const extensionsDir = resolve(strapi.dir, 'extensions');
+  const extensionsDir = strapi.dirs.extensions;
   if (!existsSync(extensionsDir)) {
     return;
   }
@@ -62,7 +62,7 @@ const formatContentTypes = plugins => {
 };
 
 const applyUserConfig = plugins => {
-  const userPluginConfigPath = join(strapi.dir, 'config', 'plugins.js');
+  const userPluginConfigPath = join(strapi.dirs.config, 'plugins.js');
   const userPluginsConfig = existsSync(userPluginConfigPath)
     ? loadConfigFile(userPluginConfigPath)
     : {};

package/lib/core/loaders/policies.js

@@ -5,7 +5,7 @@ const fse = require('fs-extra');
 
 // TODO:: allow folders with index.js inside for bigger policies
 module.exports = async function loadPolicies(strapi) {
-  const dir = join(strapi.dir, 'policies');
+  const dir = strapi.dirs.policies;
 
   if (!(await fse.pathExists(dir))) {
     return;

package/lib/core/loaders/src-index.js

@@ -0,0 +1,38 @@
+'use strict';
+
+const { resolve } = require('path');
+const { statSync, existsSync } = require('fs');
+const { yup } = require('@strapi/utils');
+
+const srcSchema = yup
+  .object()
+  .shape({
+    bootstrap: yup.mixed().isFunction(),
+    register: yup.mixed().isFunction(),
+  })
+  .noUnknown();
+
+const validateSrcIndex = srcIndex => {
+  return srcSchema.validateSync(srcIndex, { strict: true, abortEarly: false });
+};
+
+module.exports = strapi => {
+  if (!existsSync(strapi.dirs.src)) {
+    throw new Error('Missing src folder. Please create one at `./src`');
+  }
+
+  const pathToSrcIndex = resolve(strapi.dirs.src, 'index.js');
+  if (!existsSync(pathToSrcIndex) || statSync(pathToSrcIndex).isDirectory()) {
+    return {};
+  }
+
+  const srcIndex = require(pathToSrcIndex);
+
+  try {
+    validateSrcIndex(srcIndex);
+  } catch (e) {
+    strapi.stopWithError({ message: `Invalid file \`./src/index.js\`: ${e.message}` });
+  }
+
+  return srcIndex;
+};

package/lib/core/registries/hooks.js

@@ -0,0 +1,37 @@
+'use strict';
+
+const { pickBy, has } = require('lodash/fp');
+const { addNamespace, hasNamespace } = require('../utils');
+
+const hooksRegistry = () => {
+  const hooks = {};
+
+  return {
+    get(hookUID) {
+      return hooks[hookUID];
+    },
+    getAll(namespace) {
+      return pickBy((_, uid) => hasNamespace(uid, namespace))(hooks);
+    },
+    set(uid, hook) {
+      if (has(uid, hooks)) {
+        throw new Error(`hook ${uid} has already been registered.`);
+      }
+
+      hooks[uid] = hook;
+      return this;
+    },
+    add(namespace, hooks) {
+      for (const hookName in hooks) {
+        const hook = hooks[hookName];
+        const uid = addNamespace(hookName, namespace);
+
+        this.set(uid, hook);
+      }
+
+      return this;
+    },
+  };
+};
+
+module.exports = hooksRegistry;

package/lib/core/registries/services.js

@@ -6,18 +6,18 @@ const { addNamespace, hasNamespace } = require('../utils');
 
 const servicesRegistry = strapi => {
   const services = {};
-  const instanciatedServices = {};
+  const instantiatedServices = {};
 
   return {
     get(uid) {
-      if (instanciatedServices[uid]) {
-        return instanciatedServices[uid];
+      if (instantiatedServices[uid]) {
+        return instantiatedServices[uid];
       }
 
       const service = services[uid];
       if (service) {
-        instanciatedServices[uid] = service({ strapi });
-        return instanciatedServices[uid];
+        instantiatedServices[uid] = service({ strapi });
+        return instantiatedServices[uid];
       }
 
       return undefined;
@@ -28,7 +28,7 @@ const servicesRegistry = strapi => {
       return _.mapValues(filteredServices, (service, serviceUID) => this.get(serviceUID));
     },
     set(uid, value) {
-      instanciatedServices[uid] = value;
+      instantiatedServices[uid] = value;
       return this;
     },
     add(namespace, newServices) {
@@ -50,7 +50,7 @@ const servicesRegistry = strapi => {
         throw new Error(`Service ${serviceUID} doesn't exist`);
       }
       const newService = extendFn(currentService);
-      instanciatedServices[serviceUID] = newService;
+      instantiatedServices[serviceUID] = newService;
     },
   };
 };

package/lib/core-api/controller/collection-type.js

@@ -16,7 +16,7 @@ const createCollectionTypeController = ({ service, sanitize, transformResponse }
     async find(ctx) {
       const { query } = ctx;
 
-      const { results, pagination } = await service.find({ params: query });
+      const { results, pagination } = await service.find(query);
 
       return transformResponse(sanitize(results), { pagination });
     },
@@ -30,7 +30,7 @@ const createCollectionTypeController = ({ service, sanitize, transformResponse }
       const { id } = ctx.params;
       const { query } = ctx;
 
-      const entity = await service.findOne(id, { params: query });
+      const entity = await service.findOne(id, query);
 
       return transformResponse(sanitize(entity));
     },
@@ -45,7 +45,7 @@ const createCollectionTypeController = ({ service, sanitize, transformResponse }
 
       const { data, files } = parseBody(ctx);
 
-      const entity = await service.create({ params: query, data, files });
+      const entity = await service.create({ ...query, data, files });
 
       return transformResponse(sanitize(entity));
     },
@@ -61,7 +61,7 @@ const createCollectionTypeController = ({ service, sanitize, transformResponse }
 
       const { data, files } = parseBody(ctx);
 
-      const entity = await service.update(id, { params: query, data, files });
+      const entity = await service.update(id, { ...query, data, files });
 
       return transformResponse(sanitize(entity));
     },
@@ -75,7 +75,7 @@ const createCollectionTypeController = ({ service, sanitize, transformResponse }
       const { id } = ctx.params;
       const { query } = ctx;
 
-      const entity = await service.delete(id, { params: query });
+      const entity = await service.delete(id, query);
       return transformResponse(sanitize(entity));
     },
   };

package/lib/core-api/controller/single-type.js

@@ -14,7 +14,7 @@ const createSingleTypeController = ({ service, sanitize, transformResponse }) =>
      */
     async find(ctx) {
       const { query } = ctx;
-      const entity = await service.find({ params: query });
+      const entity = await service.find(query);
       return transformResponse(sanitize(entity));
     },
 
@@ -27,7 +27,7 @@ const createSingleTypeController = ({ service, sanitize, transformResponse }) =>
       const { query } = ctx.request;
       const { data, files } = parseBody(ctx);
 
-      const entity = await service.createOrUpdate({ params: query, data, files });
+      const entity = await service.createOrUpdate({ ...query, data, files });
 
       return transformResponse(sanitize(entity));
     },
@@ -35,7 +35,7 @@ const createSingleTypeController = ({ service, sanitize, transformResponse }) =>
     async delete(ctx) {
       const { query } = ctx;
 
-      const entity = await service.delete({ params: query });
+      const entity = await service.delete(query);
       return transformResponse(sanitize(entity));
     },
   };