@strapi/strapi 4.0.0-next.6 → 4.0.0

package/lib/core/registries/middlewares.js

@@ -0,0 +1,89 @@
+'use strict';
+
+const { pickBy, has } = require('lodash/fp');
+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 {
+    /**
+     * 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];
+    },
+
+    /**
+     * 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];
+        const uid = addNamespace(middlewareName, namespace);
+
+        if (has(uid, middlewares)) {
+          throw new Error(`Middleware ${uid} has already been registered.`);
+        }
+        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;
+    },
+  };
+};
+
+module.exports = middlewaresRegistry;

package/lib/core/registries/modules.js

@@ -0,0 +1,44 @@
+'use strict';
+
+const { pickBy, has } = require('lodash/fp');
+const { createModule } = require('../domain/module');
+
+const modulesRegistry = strapi => {
+  const modules = {};
+
+  return {
+    get(namespace) {
+      return modules[namespace];
+    },
+    getAll(prefix = '') {
+      return pickBy((mod, namespace) => namespace.startsWith(prefix))(modules);
+    },
+    add(namespace, rawModule) {
+      if (has(namespace, modules)) {
+        throw new Error(`Module ${namespace} has already been registered.`);
+      }
+
+      modules[namespace] = createModule(namespace, rawModule, strapi);
+      modules[namespace].load();
+
+      return modules[namespace];
+    },
+    async bootstrap() {
+      for (const mod of Object.values(modules)) {
+        await mod.bootstrap();
+      }
+    },
+    async register() {
+      for (const mod of Object.values(modules)) {
+        await mod.register();
+      }
+    },
+    async destroy() {
+      for (const mod of Object.values(modules)) {
+        await mod.destroy();
+      }
+    },
+  };
+};
+
+module.exports = modulesRegistry;

package/lib/core/registries/plugins.js

@@ -0,0 +1,28 @@
+'use strict';
+
+const { has } = require('lodash/fp');
+
+const pluginsRegistry = strapi => {
+  const plugins = {};
+
+  return {
+    get(name) {
+      return plugins[name];
+    },
+    getAll() {
+      return plugins;
+    },
+    add(name, pluginConfig) {
+      if (has(name, plugins)) {
+        throw new Error(`Plugin ${name} has already been registered.`);
+      }
+
+      const pluginModule = strapi.container.get('modules').add(`plugin::${name}`, pluginConfig);
+      plugins[name] = pluginModule;
+
+      return plugins[name];
+    },
+  };
+};
+
+module.exports = pluginsRegistry;

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;

package/lib/core/registries/policies.js

@@ -0,0 +1,89 @@
+'use strict';
+
+const { pickBy, has } = require('lodash/fp');
+const { addNamespace, hasNamespace } = require('../utils');
+
+/**
+ * @typedef {import('./policies').Policy} Policy
+ */
+
+// TODO: move instantiation part here instead of in the policy utils
+const policiesRegistry = () => {
+  const policies = {};
+
+  return {
+    /**
+     * Returns this list of registered policies uids
+     * @returns {string[]}
+     */
+    keys() {
+      return Object.keys(policies);
+    },
+
+    /**
+     * Returns the instance of a policy. Instantiate the policy if not already done
+     * @param {string} uid
+     * @returns {Policy}
+     */
+    get(uid) {
+      return policies[uid];
+    },
+
+    /**
+     * Returns a map with all the policies in a namespace
+     * @param {string} namespace
+     * @returns {{ [key: string]: Policy }}
+     */
+    getAll(namespace) {
+      return pickBy((_, uid) => hasNamespace(uid, namespace))(policies);
+    },
+
+    /**
+     * Registers a policy
+     * @param {string} uid
+     * @param {Policy} policy
+     */
+    set(uid, policy) {
+      policies[uid] = policy;
+      return this;
+    },
+
+    /**
+     * Registers a map of policies for a specific namespace
+     * @param {string} namespace
+     * @param {{ [key: string]: Policy }} newPolicies
+     * @returns
+     */
+    add(namespace, newPolicies) {
+      for (const policyName in newPolicies) {
+        const policy = newPolicies[policyName];
+        const uid = addNamespace(policyName, namespace);
+
+        if (has(uid, policies)) {
+          throw new Error(`Policy ${uid} has already been registered.`);
+        }
+        policies[uid] = policy;
+      }
+    },
+
+    /**
+     * Wraps a policy to extend it
+     * @param {string} uid
+     * @param {(policy: Policy) => Policy} extendFn
+     */
+    extend(uid, extendFn) {
+      const currentPolicy = this.get(uid);
+
+      if (!currentPolicy) {
+        throw new Error(`Policy ${uid} doesn't exist`);
+      }
+
+      const newPolicy = extendFn(currentPolicy);
+      policies[uid] = newPolicy;
+
+      return this;
+    },
+  };
+};
+
+module.exports = policiesRegistry;

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

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

package/lib/core/registries/services.js

@@ -0,0 +1,114 @@
+'use strict';
+
+const { pickBy, has } = require('lodash/fp');
+const { addNamespace, hasNamespace } = require('../utils');
+
+/**
+ * @typedef {import('./services').Service} Service
+ * @typedef {import('./services').ServiceFactory} ServiceFactory
+ */
+
+const servicesRegistry = strapi => {
+  const services = {};
+  const instantiatedServices = {};
+
+  return {
+    /**
+     * Returns this list of registered services uids
+     * @returns {string[]}
+     */
+    keys() {
+      return Object.keys(services);
+    },
+
+    /**
+     * Returns the instance of a service. Instantiate the service if not already done
+     * @param {string} uid
+     * @returns {Service}
+     */
+    get(uid) {
+      if (instantiatedServices[uid]) {
+        return instantiatedServices[uid];
+      }
+
+      const service = services[uid];
+      if (service) {
+        instantiatedServices[uid] = typeof service === 'function' ? service({ strapi }) : service;
+        return instantiatedServices[uid];
+      }
+    },
+
+    /**
+     * Returns a map with all the services in a namespace
+     * @param {string} namespace
+     * @returns {{ [key: string]: Service }}
+     */
+    getAll(namespace) {
+      const filteredServices = pickBy((_, uid) => hasNamespace(uid, namespace))(services);
+
+      // 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} service
+     */
+    set(uid, service) {
+      services[uid] = service;
+      delete instantiatedServices[uid];
+      return this;
+    },
+
+    /**
+     * Registers a map of services for a specific namespace
+     * @param {string} namespace
+     * @param {{ [key: string]: Service|ServiceFactory }} newServices
+     * @returns
+     */
+    add(namespace, newServices) {
+      for (const serviceName in newServices) {
+        const service = newServices[serviceName];
+        const uid = addNamespace(serviceName, namespace);
+
+        if (has(uid, services)) {
+          throw new Error(`Service ${uid} has already been registered.`);
+        }
+        services[uid] = service;
+      }
+
+      return this;
+    },
+
+    /**
+     * Wraps a service to extend it
+     * @param {string} uid
+     * @param {(service: Service) => Service} extendFn
+     */
+    extend(uid, extendFn) {
+      const currentService = this.get(uid);
+
+      if (!currentService) {
+        throw new Error(`Service ${uid} doesn't exist`);
+      }
+
+      const newService = extendFn(currentService);
+      instantiatedServices[uid] = newService;
+
+      return this;
+    },
+  };
+};
+
+module.exports = servicesRegistry;

package/lib/core/utils.js

@@ -0,0 +1,35 @@
+'use strict';
+
+const hasNamespace = (name, namespace) => {
+  if (!namespace) {
+    return true;
+  }
+
+  if (namespace.endsWith('::')) {
+    return name.startsWith(namespace);
+  } else {
+    return name.startsWith(`${namespace}.`);
+  }
+};
+
+const addNamespace = (name, namespace) => {
+  if (namespace.endsWith('::')) {
+    return `${namespace}${name}`;
+  } else {
+    return `${namespace}.${name}`;
+  }
+};
+
+const removeNamespace = (name, namespace) => {
+  if (namespace.endsWith('::')) {
+    return name.replace(namespace, '');
+  } else {
+    return name.replace(`${namespace}.`, '');
+  }
+};
+
+module.exports = {
+  addNamespace,
+  removeNamespace,
+  hasNamespace,
+};

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

@@ -1,12 +1,17 @@
 'use strict';
 
-const { transformResponse } = require('./transform');
+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, sanitize, parseMultipartData }) => {
+const createCollectionTypeController = ({ contentType }) => {
+  const { uid } = contentType;
+
   return {
     /**
      * Retrieve records.
@@ -16,9 +21,10 @@ const createCollectionTypeController = ({ service, sanitize, parseMultipartData
     async find(ctx) {
       const { query } = ctx;
 
-      const { results, pagination } = await service.find({ params: query });
+      const { results, pagination } = await strapi.service(uid).find(query);
+      const sanitizedResults = await this.sanitizeOutput(results, ctx);
 
-      return transformResponse(sanitize(results), { pagination });
+      return this.transformResponse(sanitizedResults, { pagination });
     },
 
     /**
@@ -30,9 +36,10 @@ const createCollectionTypeController = ({ service, sanitize, parseMultipartData
       const { id } = ctx.params;
       const { query } = ctx;
 
-      const entity = await service.findOne(id, { params: query });
+      const entity = await strapi.service(uid).findOne(id, query);
+      const sanitizedEntity = await this.sanitizeOutput(entity, ctx);
 
-      return transformResponse(sanitize(entity));
+      return this.transformResponse(sanitizedEntity);
     },
 
     /**
@@ -41,17 +48,22 @@ const createCollectionTypeController = ({ service, sanitize, parseMultipartData
      * @return {Object}
      */
     async create(ctx) {
-      const { body, query } = ctx.request;
-
-      let entity;
-      if (ctx.is('multipart')) {
-        const { data, files } = parseMultipartData(ctx);
-        entity = await service.create({ params: query, data, files });
-      } else {
-        entity = await service.create({ params: query, data: body });
+      const { query } = ctx.request;
+
+      const { data, files } = parseBody(ctx);
+
+      if (!isObject(data)) {
+        throw new ValidationError('Missing "data" payload in the request body');
       }
 
-      return transformResponse(sanitize(entity));
+      const sanitizedInputData = await this.sanitizeInput(data, ctx);
+
+      const entity = await strapi
+        .service(uid)
+        .create({ ...query, data: sanitizedInputData, files });
+      const sanitizedEntity = await this.sanitizeOutput(entity, ctx);
+
+      return this.transformResponse(sanitizedEntity);
     },
 
     /**
@@ -61,17 +73,22 @@ const createCollectionTypeController = ({ service, sanitize, parseMultipartData
      */
     async update(ctx) {
       const { id } = ctx.params;
-      const { body, query } = ctx.request;
-
-      let entity;
-      if (ctx.is('multipart')) {
-        const { data, files } = parseMultipartData(ctx);
-        entity = await service.update(id, { params: query, data, files });
-      } else {
-        entity = await service.update(id, { params: query, data: body });
+      const { query } = ctx.request;
+
+      const { data, files } = parseBody(ctx);
+
+      if (!isObject(data)) {
+        throw new ValidationError('Missing "data" payload in the request body');
       }
 
-      return transformResponse(sanitize(entity));
+      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 this.transformResponse(sanitizedEntity);
     },
 
     /**
@@ -83,8 +100,10 @@ const createCollectionTypeController = ({ service, sanitize, parseMultipartData
       const { id } = ctx.params;
       const { query } = ctx;
 
-      const entity = await service.delete(id, { params: query });
-      return transformResponse(sanitize(entity));
+      const entity = await strapi.service(uid).delete(id, query);
+      const sanitizedEntity = await this.sanitizeOutput(entity, ctx);
+
+      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

@@ -1,23 +1,45 @@
 'use strict';
 
-const { parseMultipartData, sanitizeEntity } = require('@strapi/utils');
+const { getOr } = require('lodash/fp');
 
+const { contentTypes, sanitize } = require('@strapi/utils');
+
+const { transformResponse } = require('./transform');
 const createSingleTypeController = require('./single-type');
 const createCollectionTypeController = require('./collection-type');
 
-module.exports = ({ service, model }) => {
-  const ctx = {
-    model,
-    service,
-    parseMultipartData,
-    sanitize(data) {
-      return sanitizeEntity(data, { model: strapi.getModel(model.uid) });
+const getAuthFromKoaContext = getOr({}, 'state.auth');
+
+const createController = ({ contentType }) => {
+  const ctx = { contentType };
+
+  const proto = {
+    transformResponse(data, meta) {
+      return transformResponse(data, meta, { contentType });
+    },
+
+    sanitizeOutput(data, ctx) {
+      const auth = getAuthFromKoaContext(ctx);
+
+      return sanitize.contentAPI.output(data, contentType, { auth });
+    },
+
+    sanitizeInput(data, ctx) {
+      const auth = getAuthFromKoaContext(ctx);
+
+      return sanitize.contentAPI.input(data, contentType, { auth });
     },
   };
 
-  if (model.kind === 'singleType') {
-    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 };