@strapi/strapi 4.0.0-next.8 → 4.0.2

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

@@ -1,12 +1,33 @@
 'use strict';
 
+const _ = require('lodash');
+const { removeNamespace } = require('../../utils');
 const { validateModule } = require('./validation');
 
+const uidToPath = uid => uid.replace('::', '.');
+
+// Removes the namespace from a map with keys prefixed with a namespace
+const removeNamespacedKeys = (map, namespace) => {
+  return _.mapKeys(map, (value, key) => removeNamespace(key, namespace));
+};
+
+const defaultModule = {
+  config: {},
+  routes: [],
+  controllers: {},
+  services: {},
+  contentTypes: {},
+  policies: {},
+  middlewares: {},
+};
+
 const createModule = (namespace, rawModule, strapi) => {
+  _.defaults(rawModule, defaultModule);
+
   try {
     validateModule(rawModule);
   } catch (e) {
-    throw new Error(`strapi-server.js is invalid for plugin ${namespace}.\n${e.errors.join('\n')}`);
+    throw new Error(`strapi-server.js is invalid for '${namespace}'.\n${e.errors.join('\n')}`);
   }
 
   const called = {};
@@ -16,21 +37,21 @@ const createModule = (namespace, rawModule, strapi) => {
         throw new Error(`Bootstrap for ${namespace} has already been called`);
       }
       called.bootstrap = true;
-      await rawModule.bootstrap(strapi);
+      await (rawModule.bootstrap && rawModule.bootstrap({ strapi }));
     },
     async register() {
       if (called.register) {
         throw new Error(`Register for ${namespace} has already been called`);
       }
       called.register = true;
-      await rawModule.register(strapi);
+      await (rawModule.register && rawModule.register({ strapi }));
     },
     async destroy() {
       if (called.destroy) {
         throw new Error(`Destroy for ${namespace} has already been called`);
       }
       called.destroy = true;
-      await rawModule.destroy(strapi);
+      await (rawModule.destroy && rawModule.destroy({ strapi }));
     },
     load() {
       strapi.container.get('content-types').add(namespace, rawModule.contentTypes);
@@ -38,38 +59,48 @@ const createModule = (namespace, rawModule, strapi) => {
       strapi.container.get('policies').add(namespace, rawModule.policies);
       strapi.container.get('middlewares').add(namespace, rawModule.middlewares);
       strapi.container.get('controllers').add(namespace, rawModule.controllers);
-      strapi.container.get('config').set(namespace.replace('::', '.'), rawModule.config);
+      strapi.container.get('config').set(uidToPath(namespace), rawModule.config);
+    },
+    get routes() {
+      return rawModule.routes;
+    },
+    config(path, defaultValue) {
+      return strapi.container.get('config').get(`${uidToPath(namespace)}.${path}`, defaultValue);
     },
-    routes: rawModule.routes, // TODO: to remove v3
     contentType(ctName) {
       return strapi.container.get('content-types').get(`${namespace}.${ctName}`);
     },
     get contentTypes() {
-      return strapi.container.get('content-types').getAll(namespace);
+      const contentTypes = strapi.container.get('content-types').getAll(namespace);
+      return removeNamespacedKeys(contentTypes, namespace);
     },
     service(serviceName) {
       return strapi.container.get('services').get(`${namespace}.${serviceName}`);
     },
     get services() {
-      return strapi.container.get('services').getAll(namespace);
+      const services = strapi.container.get('services').getAll(namespace);
+      return removeNamespacedKeys(services, namespace);
     },
     policy(policyName) {
       return strapi.container.get('policies').get(`${namespace}.${policyName}`);
     },
     get policies() {
-      return rawModule.policies;
+      const policies = strapi.container.get('policies').getAll(namespace);
+      return removeNamespacedKeys(policies, namespace);
     },
     middleware(middlewareName) {
       return strapi.container.get('middlewares').get(`${namespace}.${middlewareName}`);
     },
     get middlewares() {
-      return strapi.container.get('middlewares').getAll(namespace);
+      const middlewares = strapi.container.get('middlewares').getAll(namespace);
+      return removeNamespacedKeys(middlewares, namespace);
     },
     controller(controllerName) {
       return strapi.container.get('controllers').get(`${namespace}.${controllerName}`);
     },
     get controllers() {
-      return rawModule.controllers;
+      const controllers = strapi.container.get('controllers').getAll(namespace);
+      return removeNamespacedKeys(controllers, namespace);
     },
   };
 };

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

@@ -5,25 +5,22 @@ const { yup } = require('@strapi/utils');
 const strapiServerSchema = yup
   .object()
   .shape({
-    bootstrap: yup
-      .mixed()
-      .isFunction()
-      .required(),
-    destroy: yup
-      .mixed()
-      .isFunction()
-      .required(),
-    register: yup
-      .mixed()
-      .isFunction()
-      .required(),
-    config: yup.object().required(),
-    routes: yup.array().required(), // may be removed later
-    controllers: yup.object().required(), // may be removed later
-    services: yup.object().required(),
-    policies: yup.object().required(),
-    middlewares: yup.object().required(), // may be removed later
-    contentTypes: yup.object().required(),
+    bootstrap: yup.mixed().isFunction(),
+    destroy: yup.mixed().isFunction(),
+    register: yup.mixed().isFunction(),
+    config: yup.object(),
+    routes: yup.lazy(value => {
+      if (Array.isArray(value)) {
+        return yup.array();
+      } else {
+        return yup.object();
+      }
+    }),
+    controllers: yup.object(),
+    services: yup.object(),
+    policies: yup.object(),
+    middlewares: yup.object(),
+    contentTypes: yup.object(),
   })
   .noUnknown();
 

package/lib/core/loaders/admin.js

@@ -11,6 +11,6 @@ module.exports = strapi => {
   strapi.container.get('policies').add(`admin::`, strapi.admin.policies);
   strapi.container.get('middlewares').add(`admin::`, strapi.admin.middlewares);
 
-  const userAdminConfig = strapi.config.get('server.admin');
-  strapi.container.get('config').set('server.admin', _.merge(strapi.admin.config, userAdminConfig));
+  const userAdminConfig = strapi.config.get('admin');
+  strapi.container.get('config').set('admin', _.merge(strapi.admin.config, userAdminConfig));
 };

package/lib/core/loaders/apis.js

@@ -1,20 +1,159 @@
 'use strict';
 
-const { join } = require('path');
+const { join, extname, basename } = require('path');
 const { existsSync } = require('fs-extra');
 const _ = require('lodash');
-const loadFiles = require('../../load/load-files');
-const loadConfig = require('../../load/load-config-files');
+const fse = require('fs-extra');
+const { isKebabCase } = require('@strapi/utils');
+
+// to handle names with numbers in it we first check if it is already in kebabCase
+const normalizeName = name => (isKebabCase(name) ? name : _.kebabCase(name));
+
+const DEFAULT_CONTENT_TYPE = {
+  schema: {},
+  actions: {},
+  lifecycles: {},
+};
 
 module.exports = async strapi => {
-  const apiDir = join(strapi.dir, 'api');
+  if (!existsSync(strapi.dirs.api)) {
+    throw new Error('Missing api folder. Please create one at `./src/api`');
+  }
+
+  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(strapi.dirs.api, apiFD.name));
+
+      apis[apiName] = api;
+    }
+  }
+
+  validateContentTypesUnicity(apis);
+
+  for (const apiName in apis) {
+    strapi.container.get('apis').add(apiName, apis[apiName]);
+  }
+};
+
+const validateContentTypesUnicity = apis => {
+  const allApisSchemas = Object.values(apis).flatMap(api => Object.values(api.contentTypes));
+
+  const names = [];
+  allApisSchemas.forEach(({ schema }) => {
+    if (schema.info.singularName) {
+      const singularName = _.kebabCase(schema.info.singularName);
+      if (names.includes(singularName)) {
+        throw new Error(`The singular name "${schema.info.singularName}" should be unique`);
+      }
+      names.push(singularName);
+    }
+
+    if (schema.info.pluralName) {
+      const pluralName = _.kebabCase(schema.info.pluralName);
+      if (names.includes(pluralName)) {
+        throw new Error(`The plural name "${schema.info.pluralName}" should be unique`);
+      }
+      names.push(pluralName);
+    }
+  });
+};
+
+const loadAPI = async dir => {
+  const [
+    index,
+    config,
+    routes,
+    controllers,
+    services,
+    policies,
+    middlewares,
+    contentTypes,
+  ] = await Promise.all([
+    loadIndex(dir),
+    loadDir(join(dir, 'config')),
+    loadDir(join(dir, 'routes')),
+    loadDir(join(dir, 'controllers')),
+    loadDir(join(dir, 'services')),
+    loadDir(join(dir, 'policies')),
+    loadDir(join(dir, 'middlewares')),
+    loadContentTypes(join(dir, 'content-types')),
+  ]);
+
+  return {
+    ...(index || {}),
+    config: config || {},
+    routes: routes || [],
+    controllers: controllers || {},
+    services: services || {},
+    policies: policies || {},
+    middlewares: middlewares || {},
+    contentTypes: contentTypes || {},
+  };
+};
 
-  if (!existsSync(apiDir)) {
-    throw new Error(`Missing api folder. Please create one in your app root directory`);
+const loadIndex = async dir => {
+  if (await fse.pathExists(join(dir, 'index.js'))) {
+    return loadFile(join(dir, 'index.js'));
   }
+};
+
+const loadContentTypes = async dir => {
+  if (!(await fse.pathExists(dir))) {
+    return;
+  }
+
+  const fds = await fse.readdir(dir, { withFileTypes: true });
+  const contentTypes = {};
+
+  // only load folders
+  for (const fd of fds) {
+    if (fd.isFile()) {
+      continue;
+    }
 
-  const apis = await loadFiles(apiDir, '*/!(config)/**/*.*(js|json)');
-  const apiConfigs = await loadConfig(apiDir, '*/config/**/*.*(js|json)');
+    const contentTypeName = normalizeName(fd.name);
+    const contentType = await loadDir(join(dir, fd.name));
 
-  return _.merge(apis, apiConfigs);
+    contentTypes[normalizeName(contentTypeName)] = _.defaults(contentType, DEFAULT_CONTENT_TYPE);
+  }
+
+  return contentTypes;
+};
+
+const loadDir = async dir => {
+  if (!(await fse.pathExists(dir))) {
+    return;
+  }
+
+  const fds = await fse.readdir(dir, { withFileTypes: true });
+
+  const root = {};
+  for (const fd of fds) {
+    if (!fd.isFile()) {
+      continue;
+    }
+
+    const key = basename(fd.name, extname(fd.name));
+    root[normalizeName(key)] = await loadFile(join(dir, fd.name));
+  }
+
+  return root;
+};
+
+const loadFile = file => {
+  const ext = extname(file);
+
+  switch (ext) {
+    case '.js':
+      return require(file);
+    case '.json':
+      return fse.readJSON(file);
+    default:
+      return {};
+  }
 };

package/lib/core/loaders/components.js

@@ -2,23 +2,21 @@
 
 const { join } = require('path');
 const _ = require('lodash');
-const { exists } = require('fs-extra');
+const { pathExists } = require('fs-extra');
 const loadFiles = require('../../load/load-files');
 
 module.exports = async strapi => {
-  const componentsDir = join(strapi.dir, 'components');
-
-  if (!(await exists(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

@@ -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,13 +1,19 @@
 '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');
 const { isKebabCase } = require('@strapi/utils');
-const loadConfigFile = require('../../app-configuration/load-config-file');
+const getUserPluginsConfig = require('./get-user-plugins-config');
 
 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,28 +45,59 @@ 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');
-    const packageInfo = require(packagePath);
+    let packageInfo;
+    try {
+      packageInfo = require(packagePath);
+    } catch {
+      continue;
+    }
 
     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 userPluginsConfig = existsSync(userPluginConfigPath)
-    ? loadConfigFile(userPluginConfigPath)
-    : {};
+  const userPluginsConfig = await getUserPluginsConfig();
+
   _.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 +105,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;
 };