@strapi/strapi 4.0.0-next.9 → 4.0.0

package/lib/core/loaders/middlewares.js

@@ -1,136 +1,36 @@
 'use strict';
 
-// Dependencies.
-const path = require('path');
-const fs = require('fs-extra');
-const _ = require('lodash');
-const glob = require('../../load/glob');
-const findPackagePath = require('../../load/package-path');
+const { join, extname, basename } = require('path');
+const fse = require('fs-extra');
 
-/**
- * Load middlewares
- */
-module.exports = async function(strapi) {
-  const installedMiddlewares = strapi.config.get('installedMiddlewares');
-  const appPath = strapi.config.get('appPath');
+// TODO:: allow folders with index.js inside for bigger policies
+module.exports = async function loadMiddlewares(strapi) {
+  const localMiddlewares = await loadLocalMiddlewares(strapi);
+  const internalMiddlewares = require('../../middlewares');
 
-  let middlewares = {};
-
-  const loaders = createLoaders(strapi);
-
-  await loaders.loadMiddlewareDependencies(installedMiddlewares, middlewares);
-  // internal middlewares
-  await loaders.loadInternalMiddlewares(middlewares);
-  // local middleware
-  await loaders.loadLocalMiddlewares(appPath, middlewares);
-  // plugins middlewares
-  await loaders.loadPluginsMiddlewares(strapi.plugins, middlewares);
-  // local plugin middlewares
-  await loaders.loadLocalPluginsMiddlewares(appPath, middlewares);
-  // load admin middlewares
-  await loaders.loadAdminMiddlewares(middlewares);
-
-  return middlewares;
+  strapi.container.get('middlewares').add(`global::`, localMiddlewares);
+  strapi.container.get('middlewares').add(`strapi::`, internalMiddlewares);
 };
 
-/**
- * Build loader functions
- * @param {*} strapi - strapi instance
- */
-const createLoaders = strapi => {
-  const loadMiddlewaresInDir = async (dir, middlewares) => {
-    const files = await glob('*/*(index|defaults).*(js|json)', {
-      cwd: dir,
-    });
-
-    files.forEach(f => {
-      const name = f.split('/')[0];
-      mountMiddleware(name, [path.resolve(dir, f)], middlewares);
-    });
-  };
+const loadLocalMiddlewares = async strapi => {
+  const dir = strapi.dirs.middlewares;
 
-  const loadInternalMiddlewares = middlewares =>
-    loadMiddlewaresInDir(path.resolve(__dirname, '..', '..', 'middlewares'), middlewares);
+  if (!(await fse.pathExists(dir))) {
+    return {};
+  }
 
-  const loadLocalMiddlewares = (appPath, middlewares) =>
-    loadMiddlewaresInDir(path.resolve(appPath, 'middlewares'), middlewares);
+  const middlewares = {};
+  const paths = await fse.readdir(dir, { withFileTypes: true });
 
-  const loadPluginsMiddlewares = async (plugins, middlewares) => {
-    for (const pluginName in plugins) {
-      const pluginMiddlewares = plugins[pluginName].middlewares;
-      for (const middlewareName in pluginMiddlewares) {
-        middlewares[middlewareName] = {
-          loaded: false,
-          ...pluginMiddlewares[middlewareName],
-        };
-      }
-    }
-  };
-
-  const loadLocalPluginsMiddlewares = async (appPath, middlewares) => {
-    const pluginsDir = path.resolve(appPath, 'plugins');
-    if (!fs.existsSync(pluginsDir)) return;
-
-    const pluginsNames = await fs.readdir(pluginsDir);
+  for (const fd of paths) {
+    const { name } = fd;
+    const fullPath = join(dir, name);
 
-    for (let pluginFolder of pluginsNames) {
-      // ignore files
-      const stat = await fs.stat(path.resolve(pluginsDir, pluginFolder));
-      if (!stat.isDirectory()) continue;
-
-      const dir = path.resolve(pluginsDir, pluginFolder, 'middlewares');
-      await loadMiddlewaresInDir(dir, middlewares);
+    if (fd.isFile() && extname(name) === '.js') {
+      const key = basename(name, '.js');
+      middlewares[key] = require(fullPath);
     }
-  };
-
-  const loadAdminMiddlewares = async middlewares => {
-    const middlewaresDir = 'middlewares';
-    const dir = path.resolve(findPackagePath(`@strapi/admin`), middlewaresDir);
-    await loadMiddlewaresInDir(dir, middlewares);
+  }
 
-    // load ee admin middlewares if they exist
-    if (process.env.STRAPI_DISABLE_EE !== 'true' && strapi.EE) {
-      await loadMiddlewaresInDir(`${dir}/../ee/${middlewaresDir}`, middlewares);
-    }
-  };
-
-  const loadMiddlewareDependencies = async (packages, middlewares) => {
-    for (let packageName of packages) {
-      const baseDir = path.dirname(require.resolve(`@strapi/middleware-${packageName}`));
-      const files = await glob('*(index|defaults).*(js|json)', {
-        cwd: baseDir,
-        absolute: true,
-      });
-
-      mountMiddleware(packageName, files, middlewares);
-    }
-  };
-
-  const mountMiddleware = (name, files, middlewares) => {
-    files.forEach(file => {
-      middlewares[name] = middlewares[name] || { loaded: false };
-
-      if (_.endsWith(file, 'index.js') && !middlewares[name].load) {
-        return Object.defineProperty(middlewares[name], 'load', {
-          configurable: false,
-          enumerable: true,
-          get: () => require(file)(strapi),
-        });
-      }
-
-      if (_.endsWith(file, 'defaults.json')) {
-        middlewares[name].defaults = require(file);
-        return;
-      }
-    });
-  };
-
-  return {
-    loadInternalMiddlewares,
-    loadLocalMiddlewares,
-    loadPluginsMiddlewares,
-    loadLocalPluginsMiddlewares,
-    loadMiddlewareDependencies,
-    loadAdminMiddlewares,
-  };
+  return middlewares;
 };

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

@@ -1,6 +1,6 @@
 'use strict';
 
-const { dirname, join } = require('path');
+const { dirname, join, resolve } = require('path');
 const { statSync, existsSync } = require('fs');
 const _ = require('lodash');
 const { get, has, pick, pickBy, defaultsDeep, map, prop, pipe } = require('lodash/fp');
@@ -8,6 +8,12 @@ const { isKebabCase } = require('@strapi/utils');
 const loadConfigFile = require('../../app-configuration/load-config-file');
 
 const isStrapiPlugin = info => get('strapi.kind', info) === 'plugin';
+const INTERNAL_PLUGINS = [
+  '@strapi/plugin-content-manager',
+  '@strapi/plugin-content-type-builder',
+  '@strapi/plugin-email',
+  '@strapi/plugin-upload',
+];
 
 const validatePluginName = pluginName => {
   if (!isKebabCase(pluginName)) {
@@ -21,17 +27,14 @@ const toDetailedDeclaration = declaration => {
   }
 
   let detailedDeclaration = pick(['enabled'], declaration);
-  if (has('config', declaration)) {
-    detailedDeclaration.userConfig = declaration.config;
-  }
   if (has('resolve', declaration)) {
     let pathToPlugin = '';
     try {
       pathToPlugin = dirname(require.resolve(declaration.resolve));
     } catch (e) {
-      if (existsSync(declaration.resolve) && statSync(declaration.resolve).isDirectory()) {
-        pathToPlugin = declaration.resolve;
-      } else {
+      pathToPlugin = resolve(strapi.dirs.root, declaration.resolve);
+
+      if (!existsSync(pathToPlugin) || !statSync(pathToPlugin).isDirectory()) {
         throw new Error(`${declaration.resolve} couldn't be resolved`);
       }
     }
@@ -42,6 +45,18 @@ const toDetailedDeclaration = declaration => {
 };
 
 const getEnabledPlugins = async strapi => {
+  const internalPlugins = {};
+  for (const dep of INTERNAL_PLUGINS) {
+    const packagePath = join(dep, 'package.json');
+    const packageInfo = require(packagePath);
+
+    validatePluginName(packageInfo.strapi.name);
+    internalPlugins[packageInfo.strapi.name] = {
+      ...toDetailedDeclaration({ enabled: true, resolve: packagePath }),
+      info: packageInfo.strapi,
+    };
+  }
+
   const installedPlugins = {};
   for (const dep in strapi.config.get('info.dependencies', {})) {
     const packagePath = join(dep, 'package.json');
@@ -49,21 +64,38 @@ const getEnabledPlugins = async strapi => {
 
     if (isStrapiPlugin(packageInfo)) {
       validatePluginName(packageInfo.strapi.name);
-      installedPlugins[packageInfo.strapi.name] = toDetailedDeclaration({
-        enabled: true,
-        resolve: packagePath,
-      });
+      installedPlugins[packageInfo.strapi.name] = {
+        ...toDetailedDeclaration({ enabled: true, resolve: packagePath }),
+        info: packageInfo.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)
     : {};
+
   _.forEach(userPluginsConfig, (declaration, pluginName) => {
     validatePluginName(pluginName);
-    declaredPlugins[pluginName] = toDetailedDeclaration(declaration);
+
+    declaredPlugins[pluginName] = {
+      ...toDetailedDeclaration(declaration),
+      info: {},
+    };
+
+    const { pathToPlugin } = declaredPlugins[pluginName];
+
+    // for manually resolved plugins
+    if (pathToPlugin) {
+      const packagePath = join(pathToPlugin, 'package.json');
+      const packageInfo = require(packagePath);
+
+      if (isStrapiPlugin(packageInfo)) {
+        declaredPlugins[pluginName].info = packageInfo.strapi || {};
+      }
+    }
   });
 
   const declaredPluginsResolves = map(prop('pathToPlugin'), declaredPlugins);
@@ -71,10 +103,12 @@ const getEnabledPlugins = async strapi => {
     p => !declaredPluginsResolves.includes(p.pathToPlugin),
     installedPlugins
   );
+
   const enabledPlugins = pipe(
+    defaultsDeep(declaredPlugins),
     defaultsDeep(installedPluginsNotAlreadyUsed),
     pickBy(p => p.enabled)
-  )(declaredPlugins);
+  )(internalPlugins);
 
   return enabledPlugins;
 };

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

@@ -1,7 +1,7 @@
 'use strict';
 
-const { join, resolve } = require('path');
-const { existsSync } = require('fs');
+const { join } = require('path');
+const fse = require('fs-extra');
 const { defaultsDeep, getOr, get } = require('lodash/fp');
 const { env } = require('@strapi/utils');
 const loadConfigFile = require('../../app-configuration/load-config-file');
@@ -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,8 +25,8 @@ const defaultPlugin = {
 };
 
 const applyUserExtension = async plugins => {
-  const extensionsDir = resolve(strapi.dir, 'extensions');
-  if (!existsSync(extensionsDir)) {
+  const extensionsDir = strapi.dirs.extensions;
+  if (!(await fse.pathExists(extensionsDir))) {
     return;
   }
 
@@ -39,7 +39,11 @@ const applyUserExtension = async plugins => {
     for (const ctName in plugin.contentTypes) {
       const extendedSchema = get([pluginName, 'content-types', ctName, 'schema'], extendedSchemas);
       if (extendedSchema) {
-        plugin.contentTypes[ctName].schema = extendedSchema;
+        plugin.contentTypes[ctName].schema = Object.assign(
+          {},
+          plugin.contentTypes[ctName].schema,
+          extendedSchema
+        );
       }
     }
     // second: execute strapi-server extension
@@ -61,9 +65,9 @@ const formatContentTypes = plugins => {
   }
 };
 
-const applyUserConfig = plugins => {
-  const userPluginConfigPath = join(strapi.dir, 'config', 'plugins.js');
-  const userPluginsConfig = existsSync(userPluginConfigPath)
+const applyUserConfig = async plugins => {
+  const userPluginConfigPath = join(strapi.dirs.config, 'plugins.js');
+  const userPluginsConfig = (await fse.pathExists(userPluginConfigPath))
     ? loadConfigFile(userPluginConfigPath)
     : {};
 
@@ -87,15 +91,27 @@ const applyUserConfig = plugins => {
 
 const loadPlugins = async strapi => {
   const plugins = {};
+
   const enabledPlugins = await getEnabledPlugins(strapi);
 
+  strapi.config.set('enabledPlugins', enabledPlugins);
+
   for (const pluginName in enabledPlugins) {
     const enabledPlugin = enabledPlugins[pluginName];
-    const pluginServer = loadConfigFile(join(enabledPlugin.pathToPlugin, 'strapi-server.js'));
+
+    const serverEntrypointPath = join(enabledPlugin.pathToPlugin, 'strapi-server.js');
+
+    // only load plugins with a server entrypoint
+    if (!(await fse.pathExists(serverEntrypointPath))) {
+      continue;
+    }
+
+    const pluginServer = loadConfigFile(serverEntrypointPath);
     plugins[pluginName] = defaultsDeep(defaultPlugin, pluginServer);
   }
+
   // TODO: validate plugin format
-  applyUserConfig(plugins);
+  await applyUserConfig(plugins);
   await applyUserExtension(plugins);
   formatContentTypes(plugins);
 

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,39 @@
+'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(),
+    destroy: 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/apis.js

@@ -1,7 +1,6 @@
 'use strict';
 
 const { has } = require('lodash/fp');
-const { createCoreApi } = require('../../core-api');
 
 const apisRegistry = strapi => {
   const apis = {};
@@ -18,22 +17,9 @@ const apisRegistry = strapi => {
         throw new Error(`API ${apiName} has already been registered.`);
       }
 
-      const apiInstance = strapi.container.get('modules').add(`api::${apiName}`, apiConfig);
+      const api = strapi.container.get('modules').add(`api::${apiName}`, apiConfig);
 
-      for (const ctName in apiInstance.contentTypes || {}) {
-        const contentType = apiInstance.contentTypes[ctName];
-
-        const { service, controller } = createCoreApi({
-          model: contentType,
-          api: apiInstance,
-          strapi,
-        });
-
-        strapi.container.get('services').set(`api::${apiName}.${ctName}`, service);
-        strapi.container.get('controllers').set(`api::${apiName}.${ctName}`, controller);
-      }
-
-      apis[apiName] = apiInstance;
+      apis[apiName] = api;
 
       return apis[apiName];
     },

package/lib/core/registries/content-types.js

@@ -20,32 +20,76 @@ const contentTypesRegistry = () => {
   const contentTypes = {};
 
   return {
-    get(ctUID) {
-      return contentTypes[ctUID];
+    /**
+     * Returns this list of registered contentTypes uids
+     * @returns {string[]}
+     */
+    keys() {
+      return Object.keys(contentTypes);
     },
+
+    /**
+     * Returns the instance of a contentType. Instantiate the contentType if not already done
+     * @param {string} uid
+     * @returns
+     */
+    get(uid) {
+      return contentTypes[uid];
+    },
+
+    /**
+     * Returns a map with all the contentTypes in a namespace
+     * @param {string} namespace
+     */
     getAll(namespace) {
       return pickBy((_, uid) => hasNamespace(uid, namespace))(contentTypes);
     },
-    add(namespace, rawContentTypes) {
-      validateKeySameToSingularName(rawContentTypes);
 
-      for (const rawCtName in rawContentTypes) {
+    /**
+     * Registers a contentType
+     * @param {string} uid
+     * @param {Object} contentType
+     */
+    set(uid, contentType) {
+      contentTypes[uid] = contentType;
+      return this;
+    },
+
+    /**
+     * Registers a map of contentTypes for a specific namespace
+     * @param {string} namespace
+     * @param {{ [key: string]: Object }} newContentTypes
+     */
+    add(namespace, newContentTypes) {
+      validateKeySameToSingularName(newContentTypes);
+
+      for (const rawCtName in newContentTypes) {
         const uid = addNamespace(rawCtName, namespace);
 
         if (has(uid, contentTypes)) {
           throw new Error(`Content-type ${uid} has already been registered.`);
         }
 
-        contentTypes[uid] = createContentType(uid, rawContentTypes[rawCtName]);
+        contentTypes[uid] = createContentType(uid, newContentTypes[rawCtName]);
       }
     },
+
+    /**
+     * Wraps a contentType to extend it
+     * @param {string} uid
+     * @param {(contentType: Object) => Object} extendFn
+     */
     extend(ctUID, extendFn) {
       const currentContentType = this.get(ctUID);
+
       if (!currentContentType) {
         throw new Error(`Content-Type ${ctUID} doesn't exist`);
       }
+
       const newContentType = extendFn(currentContentType);
       contentTypes[ctUID] = newContentType;
+
+      return this;
     },
   };
 };

package/lib/core/registries/controllers.d.ts

@@ -0,0 +1,7 @@
+import { Strapi } from '../../';
+
+export type Controller = {
+  [key: string]: (...args: any) => any;
+};
+
+export type ControllerFactory = ({ strapi: Strapi }) => Controller;

package/lib/core/registries/controllers.js

@@ -3,20 +3,80 @@
 const { pickBy, has } = require('lodash/fp');
 const { addNamespace, hasNamespace } = require('../utils');
 
+/**
+ * @typedef {import('./controllers').Controller} Controller
+ * @typedef {import('./controllers').ControllerFactory} ControllerFactory
+ */
+
 const controllersRegistry = () => {
   const controllers = {};
+  const instances = {};
 
   return {
+    /**
+     * Returns this list of registered controllers uids
+     * @returns {string[]}
+     */
+    keys() {
+      return Object.keys(controllers);
+    },
+
+    /**
+     * Returns the instance of a controller. Instantiate the controller if not already done
+     * @param {string} uid
+     * @returns {Controller}
+     */
     get(uid) {
-      return controllers[uid];
+      if (instances[uid]) {
+        return instances[uid];
+      }
+
+      const controller = controllers[uid];
+
+      if (controller) {
+        instances[uid] = typeof controller === 'function' ? controller({ strapi }) : controller;
+        return instances[uid];
+      }
     },
+
+    /**
+     * Returns a map with all the controller in a namespace
+     * @param {string} namespace
+     * @returns {{ [key: string]: Controller }}
+     */
     getAll(namespace) {
-      return pickBy((_, uid) => hasNamespace(uid, namespace))(controllers);
+      const filteredControllers = pickBy((_, uid) => hasNamespace(uid, namespace))(controllers);
+
+      const map = {};
+      for (const uid in filteredControllers) {
+        Object.defineProperty(map, uid, {
+          enumerable: true,
+          get: () => {
+            return this.get(uid);
+          },
+        });
+      }
+
+      return map;
     },
+
+    /**
+     * Registers a controller
+     * @param {string} uid
+     * @param {Controller} controller
+     */
     set(uid, value) {
       controllers[uid] = value;
+      delete instances[uid];
       return this;
     },
+
+    /**
+     * Registers a map of controllers for a specific namespace
+     * @param {string} namespace
+     * @param {{ [key: string]: Controller|ControllerFactory }} newControllers
+     * @returns
+     */
     add(namespace, newControllers) {
       for (const controllerName in newControllers) {
         const controller = newControllers[controllerName];
@@ -27,15 +87,26 @@ const controllersRegistry = () => {
         }
         controllers[uid] = controller;
       }
+
       return this;
     },
+
+    /**
+     * Wraps a controller to extend it
+     * @param {string} uid
+     * @param {(controller: Controller) => Controller} extendFn
+     */
     extend(controllerUID, extendFn) {
       const currentController = this.get(controllerUID);
+
       if (!currentController) {
         throw new Error(`Controller ${controllerUID} doesn't exist`);
       }
+
       const newController = extendFn(currentController);
-      controllers[controllerUID] = newController;
+      instances[controllerUID] = newController;
+
+      return this;
     },
   };
 };

package/lib/core/registries/hooks.d.ts

@@ -0,0 +1,20 @@
+
+type Handler = (context: any) => any;
+
+type AsyncHook = {
+  handlers: Handler[];
+  register(handler: Handler): this;
+  delete(handler: Handler): this;
+  call(): Promise<void>;
+};
+
+
+type SyncHook = {
+  get handlers(): Handler[];
+  register(handler: Handler): this;
+  delete(handler: Handler): this;
+  call(): void;
+};
+
+
+export type Hook = AsyncHook|SyncHook