@strapi/strapi 4.0.0-next.7 → 4.0.1

package/lib/core/loaders/apis.js

@@ -0,0 +1,159 @@
+'use strict';
+
+const { join, extname, basename } = require('path');
+const { existsSync } = require('fs-extra');
+const _ = require('lodash');
+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 => {
+  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 || {},
+  };
+};
+
+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 contentTypeName = normalizeName(fd.name);
+    const contentType = await loadDir(join(dir, fd.name));
+
+    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/{load-components.js → 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(
@@ -32,6 +30,7 @@ module.exports = async strapi => {
         __schema__: _.cloneDeep(schema),
         uid,
         category,
+        modelType: 'component',
         modelName: key,
         globalId: schema.globalId || _.upperFirst(_.camelCase(`component_${uid}`)),
       });

package/lib/core/loaders/index.js

@@ -0,0 +1,11 @@
+'use strict';
+
+module.exports = {
+  loadSrcIndex: require('./src-index'),
+  loadAPIs: require('./apis'),
+  loadMiddlewares: require('./middlewares'),
+  loadComponents: require('./components'),
+  loadPolicies: require('./policies'),
+  loadPlugins: require('./plugins'),
+  loadAdmin: require('./admin'),
+};

package/lib/core/loaders/middlewares.js

@@ -0,0 +1,36 @@
+'use strict';
+
+const { join, extname, basename } = require('path');
+const fse = require('fs-extra');
+
+// 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');
+
+  strapi.container.get('middlewares').add(`global::`, localMiddlewares);
+  strapi.container.get('middlewares').add(`strapi::`, internalMiddlewares);
+};
+
+const loadLocalMiddlewares = async strapi => {
+  const dir = strapi.dirs.middlewares;
+
+  if (!(await fse.pathExists(dir))) {
+    return {};
+  }
+
+  const middlewares = {};
+  const paths = await fse.readdir(dir, { withFileTypes: true });
+
+  for (const fd of paths) {
+    const { name } = fd;
+    const fullPath = join(dir, name);
+
+    if (fd.isFile() && extname(name) === '.js') {
+      const key = basename(name, '.js');
+      middlewares[key] = require(fullPath);
+    }
+  }
+
+  return middlewares;
+};

package/lib/core/{load-plugins → 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;
 };

package/lib/core/loaders/plugins/get-user-plugins-config.js

@@ -0,0 +1,37 @@
+'use strict';
+
+const { join } = require('path');
+const fse = require('fs-extra');
+const { merge } = require('lodash/fp');
+const loadConfigFile = require('../../app-configuration/load-config-file');
+
+/**
+ * Return user defined plugins' config
+ * first load config from `config/plugins.js`
+ * and then merge config from `config/env/{env}/plugins.js`
+ * @return {Promise<{}>}
+ */
+const getUserPluginsConfig = async () => {
+  const globalUserConfigPath = join(strapi.dirs.config, 'plugins.js');
+  const currentEnvUserConfigPath = join(
+    strapi.dirs.config,
+    'env',
+    process.env.NODE_ENV,
+    'plugins.js'
+  );
+  let config = {};
+
+  // assign global user config if exists
+  if (await fse.pathExists(globalUserConfigPath)) {
+    config = loadConfigFile(globalUserConfigPath);
+  }
+
+  // and merge user config by environment if exists
+  if (await fse.pathExists(currentEnvUserConfigPath)) {
+    config = merge(config, loadConfigFile(currentEnvUserConfigPath));
+  }
+
+  return config;
+};
+
+module.exports = getUserPluginsConfig;

package/lib/core/{load-plugins → loaders/plugins}/index.js

@@ -1,20 +1,21 @@
 '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');
-const loadFiles = require('../../load/load-files');
+const loadConfigFile = require('../../app-configuration/load-config-file');
+const loadFiles = require('../../../load/load-files');
 const getEnabledPlugins = require('./get-enabled-plugins');
+const getUserPluginsConfig = require('./get-user-plugins-config');
 
 const defaultPlugin = {
-  bootstrap: () => {},
-  destroy: () => {},
-  register: () => {},
+  bootstrap() {},
+  destroy() {},
+  register() {},
   config: {
     default: {},
-    validator: () => {},
+    validator() {},
   },
   routes: [],
   controllers: {},
@@ -25,8 +26,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 +40,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,11 +66,8 @@ const formatContentTypes = plugins => {
   }
 };
 
-const applyUserConfig = plugins => {
-  const userPluginConfigPath = join(strapi.dir, 'config', 'plugins.js');
-  const userPluginsConfig = existsSync(userPluginConfigPath)
-    ? loadConfigFile(userPluginConfigPath)
-    : {};
+const applyUserConfig = async plugins => {
+  const userPluginsConfig = await getUserPluginsConfig();
 
   for (const pluginName in plugins) {
     const plugin = plugins[pluginName];
@@ -87,19 +89,33 @@ 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);
 
-  return plugins;
+  for (const pluginName in plugins) {
+    strapi.container.get('plugins').add(pluginName, plugins[pluginName]);
+  }
 };
 
 module.exports = loadPlugins;

package/lib/core/loaders/policies.js

@@ -0,0 +1,28 @@
+'use strict';
+
+const { join, extname, basename } = require('path');
+const fse = require('fs-extra');
+
+// TODO:: allow folders with index.js inside for bigger policies
+module.exports = async function loadPolicies(strapi) {
+  const dir = strapi.dirs.policies;
+
+  if (!(await fse.pathExists(dir))) {
+    return;
+  }
+
+  const policies = {};
+  const paths = await fse.readdir(dir, { withFileTypes: true });
+
+  for (const fd of paths) {
+    const { name } = fd;
+    const fullPath = join(dir, name);
+
+    if (fd.isFile() && extname(name) === '.js') {
+      const key = basename(name, '.js');
+      policies[key] = require(fullPath);
+    }
+  }
+
+  strapi.container.get('policies').add(`global::`, policies);
+};

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

@@ -0,0 +1,29 @@
+'use strict';
+
+const { has } = require('lodash/fp');
+
+const apisRegistry = strapi => {
+  const apis = {};
+
+  return {
+    get(name) {
+      return apis[name];
+    },
+    getAll() {
+      return apis;
+    },
+    add(apiName, apiConfig) {
+      if (has(apiName, apis)) {
+        throw new Error(`API ${apiName} has already been registered.`);
+      }
+
+      const api = strapi.container.get('modules').add(`api::${apiName}`, apiConfig);
+
+      apis[apiName] = api;
+
+      return apis[apiName];
+    },
+  };
+};
+
+module.exports = apisRegistry;