@strapi/strapi 4.0.0-next.8 → 4.0.2

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/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 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,15 +89,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

@@ -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;

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

@@ -2,11 +2,12 @@
 
 const { pickBy, has } = require('lodash/fp');
 const { createContentType } = require('../domain/content-type');
-const { addNamespace } = require('../utils');
+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}.`
@@ -19,29 +20,77 @@ 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];
     },
-    getAll(prefix = '') {
-      if (!prefix) {
-        return contentTypes;
-      }
 
-      return pickBy((ct, ctUID) => ctUID.startsWith(prefix))(contentTypes);
+    /**
+     * 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

@@ -1,18 +1,82 @@
 'use strict';
 
 const { pickBy, has } = require('lodash/fp');
-const { addNamespace } = require('../utils');
+const { addNamespace, hasNamespace } = require('../utils');
 
-const policiesRegistry = () => {
+/**
+ * @typedef {import('./controllers').Controller} Controller
+ * @typedef {import('./controllers').ControllerFactory} ControllerFactory
+ */
+
+const controllersRegistry = () => {
   const controllers = {};
+  const instances = {};
 
   return {
-    get(controllerUID) {
-      return controllers[controllerUID];
+    /**
+     * Returns this list of registered controllers uids
+     * @returns {string[]}
+     */
+    keys() {
+      return Object.keys(controllers);
     },
-    getAll(prefix = '') {
-      return pickBy((controller, controllerUID) => controllerUID.startsWith(prefix))(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 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];
@@ -23,8 +87,28 @@ const policiesRegistry = () => {
         }
         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 = policiesRegistry;
+module.exports = controllersRegistry;

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

package/lib/core/registries/hooks.js

@@ -0,0 +1,87 @@
+'use strict';
+
+const { pickBy } = require('lodash/fp');
+const { addNamespace, hasNamespace } = require('../utils');
+
+/**
+ * @typedef {import('./hooks').Hook} Hook
+ */
+
+const hooksRegistry = () => {
+  const hooks = {};
+
+  return {
+    /**
+     * Returns this list of registered hooks uids
+     * @returns {string[]}
+     */
+    keys() {
+      return Object.keys(hooks);
+    },
+
+    /**
+     * Returns the instance of a hook.
+     * @param {string} uid
+     * @returns {Hook}
+     */
+    get(uid) {
+      return hooks[uid];
+    },
+
+    /**
+     * Returns a map with all the hooks in a namespace
+     * @param {string} namespace
+     * @returns {{ [key: string]: Hook }}
+     */
+    getAll(namespace) {
+      return pickBy((_, uid) => hasNamespace(uid, namespace))(hooks);
+    },
+
+    /**
+     * Registers a hook
+     * @param {string} uid
+     * @param {Hook} hook
+     */
+    set(uid, hook) {
+      hooks[uid] = hook;
+      return this;
+    },
+
+    /**
+     * Registers a map of hooks for a specific namespace
+     * @param {string} namespace
+     * @param {{ [key: string]: Hook }} newHooks
+     * @returns
+     */
+    add(namespace, hooks) {
+      for (const hookName in hooks) {
+        const hook = hooks[hookName];
+        const uid = addNamespace(hookName, namespace);
+
+        this.set(uid, hook);
+      }
+
+      return this;
+    },
+
+    /**
+     * Wraps a hook to extend it
+     * @param {string} uid
+     * @param {(hook: Hook) => Hook} extendFn
+     */
+    extend(uid, extendFn) {
+      const currentHook = this.get(uid);
+
+      if (!currentHook) {
+        throw new Error(`Hook ${uid} doesn't exist`);
+      }
+
+      const newHook = extendFn(currentHook);
+      hooks[uid] = newHook;
+
+      return this;
+    },
+  };
+};
+
+module.exports = hooksRegistry;

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

@@ -0,0 +1,5 @@
+import { BaseContext, Middleware as KoaMiddleware } from 'koa';
+import { Strapi } from '../../';
+import { MiddlewareFactory } from '../../middlewares';
+
+export type Middleware = KoaMiddleware | MiddlewareFactory;

package/lib/core/registries/middlewares.js

@@ -1,18 +1,59 @@
 'use strict';
 
 const { pickBy, has } = require('lodash/fp');
-const { addNamespace } = require('../utils');
+const { addNamespace, hasNamespace } = require('../utils');
 
+/**
+ * @typedef {import('./middlewares').Middleware} Middleware
+ */
+
+// TODO: move instantiation part here instead of in the server service
 const middlewaresRegistry = () => {
   const middlewares = {};
 
   return {
-    get(middlewareUID) {
-      return middlewares[middlewareUID];
+    /**
+     * Returns this list of registered middlewares uids
+     * @returns {string[]}
+     */
+    keys() {
+      return Object.keys(middlewares);
+    },
+
+    /**
+     * Returns the instance of a middleware. Instantiate the middleware if not already done
+     * @param {string} uid
+     * @returns {Middleware}
+     */
+    get(uid) {
+      return middlewares[uid];
     },
-    getAll(prefix = '') {
-      return pickBy((middleware, middlewareUID) => middlewareUID.startsWith(prefix))(middlewares);
+
+    /**
+     * Returns a map with all the middlewares in a namespace
+     * @param {string} namespace
+     * @returns {{ [key: string]: Middleware }}
+     */
+    getAll(namespace) {
+      return pickBy((_, uid) => hasNamespace(uid, namespace))(middlewares);
     },
+
+    /**
+     * Registers a middleware
+     * @param {string} uid
+     * @param {Middleware} middleware
+     */
+    set(uid, middleware) {
+      middlewares[uid] = middleware;
+      return this;
+    },
+
+    /**
+     * Registers a map of middlewares for a specific namespace
+     * @param {string} namespace
+     * @param {{ [key: string]: Middleware }} newMiddlewares
+     * @returns
+     */
     add(namespace, rawMiddlewares) {
       for (const middlewareName in rawMiddlewares) {
         const middleware = rawMiddlewares[middlewareName];
@@ -24,6 +65,24 @@ const middlewaresRegistry = () => {
         middlewares[uid] = middleware;
       }
     },
+
+    /**
+     * Wraps a middleware to extend it
+     * @param {string} uid
+     * @param {(middleware: Middleware) => Middleware} extendFn
+     */
+    extend(uid, extendFn) {
+      const currentMiddleware = this.get(uid);
+
+      if (!currentMiddleware) {
+        throw new Error(`Middleware ${uid} doesn't exist`);
+      }
+
+      const newMiddleware = extendFn(currentMiddleware);
+      middlewares[uid] = newMiddleware;
+
+      return this;
+    },
   };
 };
 

package/lib/core/registries/modules.js

@@ -25,17 +25,17 @@ const modulesRegistry = strapi => {
     },
     async bootstrap() {
       for (const mod of Object.values(modules)) {
-        await mod.bootstrap(strapi);
+        await mod.bootstrap();
       }
     },
     async register() {
       for (const mod of Object.values(modules)) {
-        await mod.register(strapi);
+        await mod.register();
       }
     },
     async destroy() {
       for (const mod of Object.values(modules)) {
-        await mod.destroy(strapi);
+        await mod.destroy();
       }
     },
   };

package/lib/core/registries/plugins.js

@@ -17,8 +17,8 @@ const pluginsRegistry = strapi => {
         throw new Error(`Plugin ${name} has already been registered.`);
       }
 
-      const moduleInstance = strapi.container.get('modules').add(`plugin::${name}`, pluginConfig);
-      plugins[name] = moduleInstance;
+      const pluginModule = strapi.container.get('modules').add(`plugin::${name}`, pluginConfig);
+      plugins[name] = pluginModule;
 
       return plugins[name];
     },

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

@@ -0,0 +1,9 @@
+import { BaseContext } from 'koa';
+import { Strapi } from '../../';
+
+interface PolicyContext extends BaseContext {
+  type: string;
+  is(name): boolean;
+}
+
+export type Policy = (ctx: PolicyContext, { strapi: Strapi }) => boolean | undefined;