@strapi/strapi 4.14.0-beta.0 → 4.14.0

package/lib/core/loaders/middlewares.js

@@ -1,37 +0,0 @@
-'use strict';
-
-const { join, extname, basename } = require('path');
-const fse = require('fs-extra');
-const { importDefault } = require('@strapi/utils');
-
-// 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.dist.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] = importDefault(fullPath);
-    }
-  }
-
-  return middlewares;
-};

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

@@ -1,151 +0,0 @@
-'use strict';
-
-const { dirname, join, resolve } = require('path');
-const { statSync, existsSync } = require('fs');
-const _ = require('lodash');
-const { get, pickBy, defaultsDeep, map, prop, pipe } = require('lodash/fp');
-const { isKebabCase } = require('@strapi/utils');
-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)) {
-    throw new Error(`Plugin name "${pluginName}" is not in kebab (an-example-of-kebab-case)`);
-  }
-};
-
-/**
- * @typedef {Object} PluginInstallDeclaration
- * @property {boolean} enabled
- * @property {string=} resolve
- * @property {boolean=} isModule - whether the plugin is a node module or a local plugin
- */
-
-/**
- * @typedef {Object} DetailedDeclaration
- * @property {boolean} enabled
- * @property {string=} pathToPlugin
- */
-
-/**
- * @type {(declaration: PluginInstallDeclaration | boolean) => DetailedDeclaration}
- */
-const toDetailedDeclaration = (declaration) => {
-  if (typeof declaration === 'boolean') {
-    return { enabled: declaration };
-  }
-
-  const detailedDeclaration = {
-    enabled: declaration.enabled,
-  };
-
-  if (declaration?.resolve) {
-    let pathToPlugin = '';
-
-    if (declaration.isModule) {
-      /**
-       * we only want the node_module here, not the package.json
-       */
-      pathToPlugin = join(declaration.resolve, '..');
-    } else {
-      try {
-        pathToPlugin = dirname(require.resolve(declaration.resolve));
-      } catch (e) {
-        pathToPlugin = resolve(strapi.dirs.app.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, { client } = { client: false }) => {
-  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, isModule: client }),
-      info: packageInfo.strapi,
-    };
-  }
-
-  const installedPlugins = {};
-  const dependencies = strapi.config.get('info.dependencies', {});
-
-  for (const dep of Object.keys(dependencies)) {
-    const packagePath = join(dep, 'package.json');
-    let packageInfo;
-    try {
-      packageInfo = require(packagePath);
-    } catch {
-      continue;
-    }
-
-    if (isStrapiPlugin(packageInfo)) {
-      validatePluginName(packageInfo.strapi.name);
-      installedPlugins[packageInfo.strapi.name] = {
-        ...toDetailedDeclaration({ enabled: true, resolve: packagePath, isModule: client }),
-        info: {
-          ...packageInfo.strapi,
-          packageName: packageInfo.name,
-        },
-      };
-    }
-  }
-
-  const declaredPlugins = {};
-  const userPluginsConfig = await getUserPluginsConfig();
-
-  _.forEach(userPluginsConfig, (declaration, pluginName) => {
-    validatePluginName(pluginName);
-
-    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);
-  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/get-user-plugins-config.js

@@ -1,37 +0,0 @@
-'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.dist.config, 'plugins.js');
-  const currentEnvUserConfigPath = join(
-    strapi.dirs.dist.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/loaders/plugins/index.js

@@ -1,121 +0,0 @@
-'use strict';
-
-const { join } = require('path');
-const fse = require('fs-extra');
-const { defaultsDeep, defaults, 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 getUserPluginsConfig = require('./get-user-plugins-config');
-
-const defaultPlugin = {
-  bootstrap() {},
-  destroy() {},
-  register() {},
-  config: {
-    default: {},
-    validator() {},
-  },
-  routes: [],
-  controllers: {},
-  services: {},
-  policies: {},
-  middlewares: {},
-  contentTypes: {},
-};
-
-const applyUserExtension = async (plugins) => {
-  const extensionsDir = strapi.dirs.dist.extensions;
-  if (!(await fse.pathExists(extensionsDir))) {
-    return;
-  }
-
-  const extendedSchemas = await loadFiles(extensionsDir, '**/content-types/**/schema.json');
-  const strapiServers = await loadFiles(extensionsDir, '**/strapi-server.js');
-
-  for (const pluginName of Object.keys(plugins)) {
-    const plugin = plugins[pluginName];
-    // first: load json schema
-    for (const ctName of Object.keys(plugin.contentTypes)) {
-      const extendedSchema = get([pluginName, 'content-types', ctName, 'schema'], extendedSchemas);
-      if (extendedSchema) {
-        plugin.contentTypes[ctName].schema = {
-          ...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 applyUserConfig = async (plugins) => {
-  const userPluginsConfig = await getUserPluginsConfig();
-
-  for (const pluginName of Object.keys(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);
-
-  strapi.config.set('enabledPlugins', enabledPlugins);
-
-  for (const pluginName of Object.keys(enabledPlugins)) {
-    const enabledPlugin = enabledPlugins[pluginName];
-
-    let serverEntrypointPath;
-
-    try {
-      serverEntrypointPath = join(enabledPlugin.pathToPlugin, 'strapi-server.js');
-    } catch (e) {
-      throw new Error(
-        `Error loading the plugin ${pluginName} because ${pluginName} is not installed. Please either install the plugin or remove it's configuration.`
-      );
-    }
-
-    // only load plugins with a server entrypoint
-    if (!(await fse.pathExists(serverEntrypointPath))) {
-      continue;
-    }
-
-    const pluginServer = loadConfigFile(serverEntrypointPath);
-    plugins[pluginName] = {
-      ...defaultPlugin,
-      ...pluginServer,
-      config: defaults(defaultPlugin.config, pluginServer.config),
-      routes: pluginServer.routes ?? defaultPlugin.routes,
-    };
-  }
-
-  // TODO: validate plugin format
-  await applyUserConfig(plugins);
-  await applyUserExtension(plugins);
-
-  for (const pluginName of Object.keys(plugins)) {
-    strapi.container.get('plugins').add(pluginName, plugins[pluginName]);
-  }
-};
-
-module.exports = loadPlugins;

package/lib/core/loaders/policies.js

@@ -1,29 +0,0 @@
-'use strict';
-
-const { join, extname, basename } = require('path');
-const fse = require('fs-extra');
-const { importDefault } = require('@strapi/utils');
-
-// TODO:: allow folders with index.js inside for bigger policies
-module.exports = async function loadPolicies(strapi) {
-  const dir = strapi.dirs.dist.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] = importDefault(fullPath);
-    }
-  }
-
-  strapi.container.get('policies').add(`global::`, policies);
-};

package/lib/core/loaders/sanitizers.js

@@ -1,5 +0,0 @@
-'use strict';
-
-module.exports = (strapi) => {
-  strapi.container.get('sanitizers').set('content-api', { input: [], output: [], query: [] });
-};

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

@@ -1,39 +0,0 @@
-'use strict';
-
-const { resolve } = require('path');
-const { statSync, existsSync } = require('fs');
-const { yup, importDefault } = 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.dist.src)) {
-    return;
-  }
-
-  const pathToSrcIndex = resolve(strapi.dirs.dist.src, 'index.js');
-  if (!existsSync(pathToSrcIndex) || statSync(pathToSrcIndex).isDirectory()) {
-    return {};
-  }
-
-  const srcIndex = importDefault(pathToSrcIndex);
-
-  try {
-    validateSrcIndex(srcIndex);
-  } catch (e) {
-    strapi.stopWithError({ message: `Invalid file \`./src/index.js\`: ${e.message}` });
-  }
-
-  return srcIndex;
-};

package/lib/core/loaders/validators.js

@@ -1,5 +0,0 @@
-'use strict';
-
-module.exports = (strapi) => {
-  strapi.container.get('validators').set('content-api', { input: [], query: [] });
-};

package/lib/core/registries/apis.js

@@ -1,29 +0,0 @@
-'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;

package/lib/core/registries/config.js

@@ -1,21 +0,0 @@
-'use strict';
-
-const _ = require('lodash');
-
-module.exports = (initialConfig = {}) => {
-  const _config = { ...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

@@ -1,97 +0,0 @@
-'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 of Object.keys(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 {
-    /**
-     * 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);
-    },
-
-    /**
-     * 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 of Object.keys(newContentTypes)) {
-        const uid = addNamespace(rawCtName, namespace);
-
-        if (has(uid, contentTypes)) {
-          throw new Error(`Content-type ${uid} has already been registered.`);
-        }
-
-        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;
-    },
-  };
-};
-
-module.exports = contentTypesRegistry;

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

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

package/lib/core/registries/controllers.js

@@ -1,114 +0,0 @@
-'use strict';
-
-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) {
-      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) {
-      const filteredControllers = pickBy((_, uid) => hasNamespace(uid, namespace))(controllers);
-
-      const map = {};
-      for (const uid of Object.keys(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 of Object.keys(newControllers)) {
-        const controller = newControllers[controllerName];
-        const uid = addNamespace(controllerName, namespace);
-
-        if (has(uid, controllers)) {
-          throw new Error(`Controller ${uid} has already been registered.`);
-        }
-        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);
-      instances[controllerUID] = newController;
-
-      return this;
-    },
-  };
-};
-
-module.exports = controllersRegistry;