@strapi/strapi 4.0.0-beta.0

package/lib/core/loaders/apis.js

@@ -0,0 +1,157 @@
+'use strict';
+
+const { join, extname, basename } = require('path');
+const { existsSync } = require('fs-extra');
+const _ = require('lodash');
+const fse = require('fs-extra');
+
+const normalizeName = _.kebabCase;
+
+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/components.js

@@ -0,0 +1,41 @@
+'use strict';
+
+const { join } = require('path');
+const _ = require('lodash');
+const { pathExists } = require('fs-extra');
+const loadFiles = require('../../load/load-files');
+
+module.exports = async strapi => {
+  if (!(await pathExists(strapi.dirs.components))) {
+    return {};
+  }
+
+  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(strapi.dirs.components, category, schema.__filename__);
+
+      if (!schema.collectionName) {
+        return strapi.stopWithError(
+          `Component ${key} is missing a "collectionName" property.\nVerify file ${filePath}.`
+        );
+      }
+
+      const uid = `${category}.${key}`;
+
+      acc[uid] = Object.assign(schema, {
+        __schema__: _.cloneDeep(schema),
+        uid,
+        category,
+        modelType: 'component',
+        modelName: key,
+        globalId: schema.globalId || _.upperFirst(_.camelCase(`component_${uid}`)),
+      });
+    });
+
+    return acc;
+  }, {});
+};

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,86 @@
+'use strict';
+
+// Dependencies.
+const path = require('path');
+const _ = require('lodash');
+const glob = require('../../load/glob');
+
+/**
+ * Load middlewares
+ */
+module.exports = async function(strapi) {
+  const installedMiddlewares = strapi.config.get('installedMiddlewares');
+  const appPath = strapi.config.get('appPath');
+
+  let middlewares = {};
+
+  const loaders = createLoaders(strapi);
+
+  await loaders.loadMiddlewareDependencies(installedMiddlewares, middlewares);
+  // internal middlewares
+  await loaders.loadInternalMiddlewares(middlewares);
+  // local middleware
+  await loaders.loadLocalMiddlewares(appPath, middlewares);
+
+  return middlewares;
+};
+
+/**
+ * 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 loadInternalMiddlewares = middlewares =>
+    loadMiddlewaresInDir(path.resolve(__dirname, '..', '..', 'middlewares'), middlewares);
+
+  const loadLocalMiddlewares = (appPath, middlewares) =>
+    loadMiddlewaresInDir(path.resolve(appPath, 'src', 'middlewares'), 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,
+    loadMiddlewareDependencies,
+  };
+};

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

@@ -0,0 +1,100 @@
+'use strict';
+
+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 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)) {
+    throw new Error(`Plugin name "${pluginName}" is not in kebab (an-example-of-kebab-case)`);
+  }
+};
+
+const toDetailedDeclaration = declaration => {
+  if (typeof declaration === 'boolean') {
+    return { enabled: declaration };
+  }
+
+  let detailedDeclaration = pick(['enabled'], declaration);
+  if (has('resolve', declaration)) {
+    let pathToPlugin = '';
+    try {
+      pathToPlugin = dirname(require.resolve(declaration.resolve));
+    } catch (e) {
+      pathToPlugin = resolve(strapi.dirs.root, declaration.resolve);
+
+      if (!existsSync(pathToPlugin) || !statSync(pathToPlugin).isDirectory()) {
+        throw new Error(`${declaration.resolve} couldn't be resolved`);
+      }
+    }
+
+    detailedDeclaration.pathToPlugin = pathToPlugin;
+  }
+  return detailedDeclaration;
+};
+
+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,
+    });
+  }
+
+  const installedPlugins = {};
+  for (const dep in strapi.config.get('info.dependencies', {})) {
+    const packagePath = join(dep, 'package.json');
+    const packageInfo = require(packagePath);
+
+    if (isStrapiPlugin(packageInfo)) {
+      validatePluginName(packageInfo.strapi.name);
+      installedPlugins[packageInfo.strapi.name] = toDetailedDeclaration({
+        enabled: true,
+        resolve: packagePath,
+      });
+    }
+  }
+
+  const declaredPlugins = {};
+  const userPluginConfigPath = join(strapi.dirs.config, 'plugins.js');
+  const userPluginsConfig = existsSync(userPluginConfigPath)
+    ? loadConfigFile(userPluginConfigPath)
+    : {};
+
+  _.forEach(userPluginsConfig, (declaration, pluginName) => {
+    validatePluginName(pluginName);
+    declaredPlugins[pluginName] = toDetailedDeclaration(declaration);
+  });
+
+  const declaredPluginsResolves = map(prop('pathToPlugin'), declaredPlugins);
+  const installedPluginsNotAlreadyUsed = pickBy(
+    p => !declaredPluginsResolves.includes(p.pathToPlugin),
+    installedPlugins
+  );
+
+  const enabledPlugins = pipe(
+    defaultsDeep(declaredPlugins),
+    defaultsDeep(installedPluginsNotAlreadyUsed),
+    pickBy(p => p.enabled)
+  )(internalPlugins);
+
+  return enabledPlugins;
+};
+
+module.exports = getEnabledPlugins;

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

@@ -0,0 +1,109 @@
+'use strict';
+
+const { join } = require('path');
+const { existsSync } = require('fs');
+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 getEnabledPlugins = require('./get-enabled-plugins');
+
+const defaultPlugin = {
+  bootstrap() {},
+  destroy() {},
+  register() {},
+  config: {
+    default: {},
+    validator() {},
+  },
+  routes: [],
+  controllers: {},
+  services: {},
+  policies: {},
+  middlewares: {},
+  contentTypes: {},
+};
+
+const applyUserExtension = async plugins => {
+  const extensionsDir = strapi.dirs.extensions;
+  if (!existsSync(extensionsDir)) {
+    return;
+  }
+
+  const extendedSchemas = await loadFiles(extensionsDir, '**/content-types/**/schema.json');
+  const strapiServers = await loadFiles(extensionsDir, '**/strapi-server.js');
+
+  for (const pluginName in plugins) {
+    const plugin = plugins[pluginName];
+    // first: load json schema
+    for (const ctName in plugin.contentTypes) {
+      const extendedSchema = get([pluginName, 'content-types', ctName, 'schema'], extendedSchemas);
+      if (extendedSchema) {
+        plugin.contentTypes[ctName].schema = extendedSchema;
+      }
+    }
+    // second: execute strapi-server extension
+    const strapiServer = get([pluginName, 'strapi-server'], strapiServers);
+    if (strapiServer) {
+      plugins[pluginName] = await strapiServer(plugin);
+    }
+  }
+};
+
+const formatContentTypes = plugins => {
+  for (const pluginName in plugins) {
+    const plugin = plugins[pluginName];
+    for (const contentTypeName in plugin.contentTypes) {
+      const ctSchema = plugin.contentTypes[contentTypeName].schema;
+      ctSchema.plugin = pluginName;
+      ctSchema.uid = `plugin::${pluginName}.${ctSchema.singularName}`;
+    }
+  }
+};
+
+const applyUserConfig = plugins => {
+  const userPluginConfigPath = join(strapi.dirs.config, 'plugins.js');
+  const userPluginsConfig = existsSync(userPluginConfigPath)
+    ? loadConfigFile(userPluginConfigPath)
+    : {};
+
+  for (const pluginName in plugins) {
+    const plugin = plugins[pluginName];
+    const userPluginConfig = getOr({}, `${pluginName}.config`, userPluginsConfig);
+    const defaultConfig =
+      typeof plugin.config.default === 'function'
+        ? plugin.config.default({ env })
+        : plugin.config.default;
+
+    const config = defaultsDeep(defaultConfig, userPluginConfig);
+    try {
+      plugin.config.validator(config);
+    } catch (e) {
+      throw new Error(`Error regarding ${pluginName} config: ${e.message}`);
+    }
+    plugin.config = config;
+  }
+};
+
+const loadPlugins = async strapi => {
+  const plugins = {};
+
+  const enabledPlugins = await getEnabledPlugins(strapi);
+
+  for (const pluginName in enabledPlugins) {
+    const enabledPlugin = enabledPlugins[pluginName];
+    const pluginServer = loadConfigFile(join(enabledPlugin.pathToPlugin, 'strapi-server.js'));
+    plugins[pluginName] = defaultsDeep(defaultPlugin, pluginServer);
+  }
+
+  // TODO: validate plugin format
+  applyUserConfig(plugins);
+  await applyUserExtension(plugins);
+  formatContentTypes(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,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/apis.js

@@ -0,0 +1,43 @@
+'use strict';
+
+const { has } = require('lodash/fp');
+const { createCoreApi } = require('../../core-api');
+
+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 apiInstance = 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;
+
+      return apis[apiName];
+    },
+  };
+};
+
+module.exports = apisRegistry;

package/lib/core/registries/config.js

@@ -0,0 +1,21 @@
+'use strict';
+
+const _ = require('lodash');
+
+module.exports = (initialConfig = {}) => {
+  const _config = Object.assign({}, initialConfig); // not deep clone because it would break some config
+
+  return {
+    ..._config, // TODO: to remove
+    get(path, defaultValue) {
+      return _.get(_config, path, defaultValue);
+    },
+    set(path, val) {
+      _.set(_config, path, val);
+      return this;
+    },
+    has(path) {
+      return _.has(_config, path);
+    },
+  };
+};

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

@@ -0,0 +1,53 @@
+'use strict';
+
+const { pickBy, has } = require('lodash/fp');
+const { createContentType } = require('../domain/content-type');
+const { addNamespace, hasNamespace } = require('../utils');
+
+const validateKeySameToSingularName = contentTypes => {
+  for (const ctName in contentTypes) {
+    const contentType = contentTypes[ctName];
+
+    if (ctName !== contentType.schema.info.singularName) {
+      throw new Error(
+        `The key of the content-type should be the same as its singularName. Found ${ctName} and ${contentType.schema.info.singularName}.`
+      );
+    }
+  }
+};
+
+const contentTypesRegistry = () => {
+  const contentTypes = {};
+
+  return {
+    get(ctUID) {
+      return contentTypes[ctUID];
+    },
+    getAll(namespace) {
+      return pickBy((_, uid) => hasNamespace(uid, namespace))(contentTypes);
+    },
+    add(namespace, rawContentTypes) {
+      validateKeySameToSingularName(rawContentTypes);
+
+      for (const rawCtName in rawContentTypes) {
+        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]);
+      }
+    },
+    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;
+    },
+  };
+};
+
+module.exports = contentTypesRegistry;