@strapi/strapi 4.0.0-beta.11 → 4.0.0-beta.15

package/lib/Strapi.js

@@ -366,7 +366,7 @@ class Strapi {
     this.telemetry.bootstrap();
 
     let oldContentTypes;
-    if (await this.db.connection.schema.hasTable(coreStoreModel.collectionName)) {
+    if (await this.db.getSchemaConnection().hasTable(coreStoreModel.collectionName)) {
       oldContentTypes = await this.store.get({
         type: 'strapi',
         name: 'content_types',
@@ -463,13 +463,13 @@ class Strapi {
     await this.container.get('modules')[lifecycleName]();
 
     // user
-    const userLifecycleFunction = this.app[lifecycleName];
+    const userLifecycleFunction = this.app && this.app[lifecycleName];
     if (isFunction(userLifecycleFunction)) {
       await userLifecycleFunction({ strapi: this });
     }
 
     // admin
-    const adminLifecycleFunction = this.admin[lifecycleName];
+    const adminLifecycleFunction = this.admin && this.admin[lifecycleName];
     if (isFunction(adminLifecycleFunction)) {
       await adminLifecycleFunction({ strapi: this });
     }

package/lib/commands/new.js

@@ -1,5 +1,7 @@
 'use strict';
 
+const { generateNewApp } = require('@strapi/generate-new');
+
 /**
  * `$ strapi new`
  *
@@ -7,5 +9,5 @@
  */
 
 module.exports = function(...args) {
-  return require('@strapi/generate-new')(...args);
+  return generateNewApp(...args);
 };

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

@@ -61,7 +61,9 @@ const createModule = (namespace, rawModule, strapi) => {
       strapi.container.get('controllers').add(namespace, rawModule.controllers);
       strapi.container.get('config').set(uidToPath(namespace), rawModule.config);
     },
-    routes: rawModule.routes,
+    get routes() {
+      return rawModule.routes;
+    },
     config(path, defaultValue) {
       return strapi.container.get('config').get(`${uidToPath(namespace)}.${path}`, defaultValue);
     },

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

@@ -1,6 +1,5 @@
 'use strict';
 
-const _ = require('lodash');
 const { yup } = require('@strapi/utils');
 
 const strapiServerSchema = yup
@@ -14,9 +13,7 @@ const strapiServerSchema = yup
       if (Array.isArray(value)) {
         return yup.array();
       } else {
-        const shape = _.mapValues(value, () => yup.object({ routes: yup.array().required() }));
-
-        return yup.object(shape);
+        return yup.object();
       }
     }),
     controllers: yup.object(),

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

@@ -51,10 +51,10 @@ const getEnabledPlugins = async strapi => {
     const packageInfo = require(packagePath);
 
     validatePluginName(packageInfo.strapi.name);
-    internalPlugins[packageInfo.strapi.name] = toDetailedDeclaration({
-      enabled: true,
-      resolve: packagePath,
-    });
+    internalPlugins[packageInfo.strapi.name] = {
+      ...toDetailedDeclaration({ enabled: true, resolve: packagePath }),
+      info: packageInfo.strapi,
+    };
   }
 
   const installedPlugins = {};
@@ -64,10 +64,10 @@ const getEnabledPlugins = async strapi => {
 
     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,
+      };
     }
   }
 
@@ -79,7 +79,23 @@ const getEnabledPlugins = async strapi => {
 
   _.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);

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

@@ -1,7 +1,7 @@
 'use strict';
 
 const { join } = require('path');
-const { existsSync } = require('fs');
+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');
@@ -26,7 +26,7 @@ const defaultPlugin = {
 
 const applyUserExtension = async plugins => {
   const extensionsDir = strapi.dirs.extensions;
-  if (!existsSync(extensionsDir)) {
+  if (!(await fse.pathExists(extensionsDir))) {
     return;
   }
 
@@ -61,9 +61,9 @@ const formatContentTypes = plugins => {
   }
 };
 
-const applyUserConfig = plugins => {
+const applyUserConfig = async plugins => {
   const userPluginConfigPath = join(strapi.dirs.config, 'plugins.js');
-  const userPluginsConfig = existsSync(userPluginConfigPath)
+  const userPluginsConfig = (await fse.pathExists(userPluginConfigPath))
     ? loadConfigFile(userPluginConfigPath)
     : {};
 
@@ -90,14 +90,24 @@ const loadPlugins = async strapi => {
 
   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/registries/apis.js

@@ -1,7 +1,6 @@
 'use strict';
 
 const { has } = require('lodash/fp');
-const { createCoreApi } = require('../../core-api');
 
 const apisRegistry = strapi => {
   const apis = {};
@@ -18,22 +17,9 @@ const apisRegistry = strapi => {
         throw new Error(`API ${apiName} has already been registered.`);
       }
 
-      const apiInstance = strapi.container.get('modules').add(`api::${apiName}`, apiConfig);
+      const api = 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;
+      apis[apiName] = api;
 
       return apis[apiName];
     },

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

@@ -3,20 +3,80 @@
 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) {
-      return controllers[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) {
-      return pickBy((_, uid) => hasNamespace(uid, namespace))(controllers);
+      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];
@@ -27,15 +87,26 @@ const controllersRegistry = () => {
         }
         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);
-      controllers[controllerUID] = newController;
+      instances[controllerUID] = newController;
+
+      return this;
     },
   };
 };

package/lib/core/registries/services.js

@@ -1,6 +1,5 @@
 'use strict';
 
-const _ = require('lodash');
 const { pickBy, has } = require('lodash/fp');
 const { addNamespace, hasNamespace } = require('../utils');
 
@@ -37,8 +36,6 @@ const servicesRegistry = strapi => {
         instantiatedServices[uid] = typeof service === 'function' ? service({ strapi }) : service;
         return instantiatedServices[uid];
       }
-
-      return undefined;
     },
 
     /**
@@ -49,16 +46,28 @@ const servicesRegistry = strapi => {
     getAll(namespace) {
       const filteredServices = pickBy((_, uid) => hasNamespace(uid, namespace))(services);
 
-      return _.mapValues(filteredServices, (service, serviceUID) => this.get(serviceUID));
+      // create lazy accessor to avoid instantiating the services;
+      const map = {};
+      for (const uid in filteredServices) {
+        Object.defineProperty(map, uid, {
+          enumerable: true,
+          get: () => {
+            return this.get(uid);
+          },
+        });
+      }
+
+      return map;
     },
 
     /**
      * Registers a service
      * @param {string} uid
-     * @param {Service|ServiceFactory} service
+     * @param {Service} service
      */
     set(uid, service) {
-      instantiatedServices[uid] = service;
+      services[uid] = service;
+      delete instantiatedServices[uid];
       return this;
     },
 

package/lib/core-api/controller/collection-type.js

@@ -1,17 +1,17 @@
 'use strict';
 
+const { isObject } = require('lodash/fp');
+const { ValidationError } = require('@strapi/utils').errors;
+
 const { parseBody } = require('./transform');
 
 /**
  *
  * Returns a collection type controller to handle default core-api actions
  */
-const createCollectionTypeController = ({
-  service,
-  sanitizeInput,
-  sanitizeOutput,
-  transformResponse,
-}) => {
+const createCollectionTypeController = ({ contentType }) => {
+  const { uid } = contentType;
+
   return {
     /**
      * Retrieve records.
@@ -21,10 +21,10 @@ const createCollectionTypeController = ({
     async find(ctx) {
       const { query } = ctx;
 
-      const { results, pagination } = await service.find(query);
-      const sanitizedResults = await sanitizeOutput(results, ctx);
+      const { results, pagination } = await strapi.service(uid).find(query);
+      const sanitizedResults = await this.sanitizeOutput(results, ctx);
 
-      return transformResponse(sanitizedResults, { pagination });
+      return this.transformResponse(sanitizedResults, { pagination });
     },
 
     /**
@@ -36,10 +36,10 @@ const createCollectionTypeController = ({
       const { id } = ctx.params;
       const { query } = ctx;
 
-      const entity = await service.findOne(id, query);
-      const sanitizedEntity = await sanitizeOutput(entity, ctx);
+      const entity = await strapi.service(uid).findOne(id, query);
+      const sanitizedEntity = await this.sanitizeOutput(entity, ctx);
 
-      return transformResponse(sanitizedEntity);
+      return this.transformResponse(sanitizedEntity);
     },
 
     /**
@@ -51,12 +51,19 @@ const createCollectionTypeController = ({
       const { query } = ctx.request;
 
       const { data, files } = parseBody(ctx);
-      const sanitizedInputData = await sanitizeInput(data, ctx);
 
-      const entity = await service.create({ ...query, data: sanitizedInputData, files });
-      const sanitizedEntity = await sanitizeOutput(entity, ctx);
+      if (!isObject(data)) {
+        throw new ValidationError('Missing "data" payload in the request body');
+      }
+
+      const sanitizedInputData = await this.sanitizeInput(data, ctx);
 
-      return transformResponse(sanitizedEntity);
+      const entity = await strapi
+        .service(uid)
+        .create({ ...query, data: sanitizedInputData, files });
+      const sanitizedEntity = await this.sanitizeOutput(entity, ctx);
+
+      return this.transformResponse(sanitizedEntity);
     },
 
     /**
@@ -69,12 +76,19 @@ const createCollectionTypeController = ({
       const { query } = ctx.request;
 
       const { data, files } = parseBody(ctx);
-      const sanitizedInputData = await sanitizeInput(data, ctx);
 
-      const entity = await service.update(id, { ...query, data: sanitizedInputData, files });
-      const sanitizedEntity = await sanitizeOutput(entity, ctx);
+      if (!isObject(data)) {
+        throw new ValidationError('Missing "data" payload in the request body');
+      }
+
+      const sanitizedInputData = await this.sanitizeInput(data, ctx);
+
+      const entity = await strapi
+        .service(uid)
+        .update(id, { ...query, data: sanitizedInputData, files });
+      const sanitizedEntity = await this.sanitizeOutput(entity, ctx);
 
-      return transformResponse(sanitizedEntity);
+      return this.transformResponse(sanitizedEntity);
     },
 
     /**
@@ -86,10 +100,10 @@ const createCollectionTypeController = ({
       const { id } = ctx.params;
       const { query } = ctx;
 
-      const entity = await service.delete(id, query);
-      const sanitizedEntity = await sanitizeOutput(entity, ctx);
+      const entity = await strapi.service(uid).delete(id, query);
+      const sanitizedEntity = await this.sanitizeOutput(entity, ctx);
 
-      return transformResponse(sanitizedEntity);
+      return this.transformResponse(sanitizedEntity);
     },
   };
 };

package/lib/core-api/controller/index.d.ts

@@ -0,0 +1,25 @@
+import { Context } from 'koa';
+
+type Response = object;
+
+interface BaseController {
+  transformResponse(data: object, meta: object): object;
+  sanitizeOutput(data: object, ctx: Context): Promise<object>;
+  sanitizeInput(data: object, ctx: Context): Promise<object>;
+}
+
+export interface SingleTypeController extends BaseController {
+  find(ctx: Context): Promise<Response>;
+  update(ctx: Context): Promise<Response>;
+  delete(ctx: Context): Promise<Response>;
+}
+
+export interface CollectionTypeController extends BaseController {
+  find(ctx: Context): Promise<Response>;
+  findOne(ctx: Context): Promise<Response>;
+  create(ctx: Context): Promise<Response>;
+  update(ctx: Context): Promise<Response>;
+  delete(ctx: Context): Promise<Response>;
+}
+
+export type Controller = SingleTypeController | CollectionTypeController;

package/lib/core-api/controller/index.js

@@ -10,31 +10,36 @@ const createCollectionTypeController = require('./collection-type');
 
 const getAuthFromKoaContext = getOr({}, 'state.auth');
 
-module.exports = ({ service, model }) => {
-  const ctx = {
-    model,
-    service,
+const createController = ({ contentType }) => {
+  const ctx = { contentType };
 
+  const proto = {
     transformResponse(data, meta) {
-      return transformResponse(data, meta, { contentType: model });
+      return transformResponse(data, meta, { contentType });
     },
 
     sanitizeOutput(data, ctx) {
       const auth = getAuthFromKoaContext(ctx);
 
-      return sanitize.contentAPI.output(data, strapi.getModel(model.uid), { auth });
+      return sanitize.contentAPI.output(data, contentType, { auth });
     },
 
     sanitizeInput(data, ctx) {
       const auth = getAuthFromKoaContext(ctx);
 
-      return sanitize.contentAPI.input(data, strapi.getModel(model.uid), { auth });
+      return sanitize.contentAPI.input(data, contentType, { auth });
     },
   };
 
-  if (contentTypes.isSingleType(model)) {
-    return createSingleTypeController(ctx);
+  let ctrl;
+
+  if (contentTypes.isSingleType(contentType)) {
+    ctrl = createSingleTypeController(ctx);
+  } else {
+    ctrl = createCollectionTypeController(ctx);
   }
 
-  return createCollectionTypeController(ctx);
+  return Object.assign(Object.create(proto), ctrl);
 };
+
+module.exports = { createController };

package/lib/core-api/controller/single-type.js

@@ -1,16 +1,16 @@
 'use strict';
 
+const { isObject } = require('lodash/fp');
+const { ValidationError } = require('@strapi/utils').errors;
+
 const { parseBody } = require('./transform');
 
 /**
  * Returns a single type controller to handle default core-api actions
  */
-const createSingleTypeController = ({
-  service,
-  sanitizeInput,
-  sanitizeOutput,
-  transformResponse,
-}) => {
+const createSingleTypeController = ({ contentType }) => {
+  const { uid } = contentType;
+
   return {
     /**
      * Retrieve single type content
@@ -20,10 +20,10 @@ const createSingleTypeController = ({
     async find(ctx) {
       const { query } = ctx;
 
-      const entity = await service.find(query);
-      const sanitizedEntity = await sanitizeOutput(entity, ctx);
+      const entity = await strapi.service(uid).find(query);
+      const sanitizedEntity = await this.sanitizeOutput(entity, ctx);
 
-      return transformResponse(sanitizedEntity);
+      return this.transformResponse(sanitizedEntity);
     },
 
     /**
@@ -34,21 +34,28 @@ const createSingleTypeController = ({
     async update(ctx) {
       const { query } = ctx.request;
       const { data, files } = parseBody(ctx);
-      const sanitizedInputData = await sanitizeInput(data, ctx);
 
-      const entity = await service.createOrUpdate({ ...query, data: sanitizedInputData, files });
-      const sanitizedEntity = await sanitizeOutput(entity, ctx);
+      if (!isObject(data)) {
+        throw new ValidationError('Missing "data" payload in the request body');
+      }
+
+      const sanitizedInputData = await this.sanitizeInput(data, ctx);
+
+      const entity = await strapi
+        .service(uid)
+        .createOrUpdate({ ...query, data: sanitizedInputData, files });
+      const sanitizedEntity = await this.sanitizeOutput(entity, ctx);
 
-      return transformResponse(sanitizedEntity);
+      return this.transformResponse(sanitizedEntity);
     },
 
     async delete(ctx) {
       const { query } = ctx;
 
-      const entity = await service.delete(query);
-      const sanitizedEntity = await sanitizeOutput(entity, ctx);
+      const entity = await strapi.service(uid).delete(query);
+      const sanitizedEntity = await this.sanitizeOutput(entity, ctx);
 
-      return transformResponse(sanitizedEntity);
+      return this.transformResponse(sanitizedEntity);
     },
   };
 };