@strapi/strapi 4.0.0-next.9 → 4.0.0

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

@@ -3,16 +3,57 @@
 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 {
-    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];
     },
+
+    /**
+     * 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;

package/lib/core/registries/policies.js

@@ -3,16 +3,57 @@
 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 {
-    get(policyUID) {
-      return policies[policyUID];
+    /**
+     * 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];
@@ -24,13 +65,23 @@ const policiesRegistry = () => {
         policies[uid] = policy;
       }
     },
-    extend(policyUID, extendFn) {
-      const currentPolicy = this.get(policyUID);
+
+    /**
+     * 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 ${policyUID} doesn't exist`);
+        throw new Error(`Policy ${uid} doesn't exist`);
       }
+
       const newPolicy = extendFn(currentPolicy);
-      policies[policyUID] = newPolicy;
+      policies[uid] = newPolicy;
+
+      return this;
     },
   };
 };

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

@@ -1,36 +1,82 @@
 'use strict';
 
-const _ = require('lodash');
 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 instanciatedServices = {};
+  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 (instanciatedServices[uid]) {
-        return instanciatedServices[uid];
+      if (instantiatedServices[uid]) {
+        return instantiatedServices[uid];
       }
 
       const service = services[uid];
       if (service) {
-        instanciatedServices[uid] = service({ strapi });
-        return instanciatedServices[uid];
+        instantiatedServices[uid] = typeof service === 'function' ? service({ strapi }) : service;
+        return instantiatedServices[uid];
       }
-
-      return undefined;
     },
+
+    /**
+     * 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);
 
-      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;
     },
-    set(uid, value) {
-      instanciatedServices[uid] = value;
+
+    /**
+     * 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];
@@ -44,13 +90,23 @@ const servicesRegistry = strapi => {
 
       return this;
     },
-    extend(serviceUID, extendFn) {
-      const currentService = this.get(serviceUID);
+
+    /**
+     * 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 ${serviceUID} doesn't exist`);
+        throw new Error(`Service ${uid} doesn't exist`);
       }
+
       const newService = extendFn(currentService);
-      instanciatedServices[serviceUID] = newService;
+      instantiatedServices[uid] = newService;
+
+      return this;
     },
   };
 };

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

@@ -1,12 +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, sanitize, transformResponse }) => {
+const createCollectionTypeController = ({ contentType }) => {
+  const { uid } = contentType;
+
   return {
     /**
      * Retrieve records.
@@ -16,9 +21,10 @@ const createCollectionTypeController = ({ service, sanitize, transformResponse }
     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, transformResponse }
       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);
     },
 
     /**
@@ -45,9 +52,18 @@ const createCollectionTypeController = ({ service, sanitize, transformResponse }
 
       const { data, files } = parseBody(ctx);
 
-      const entity = await service.create({ params: query, data, files });
+      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)
+        .create({ ...query, data: sanitizedInputData, files });
+      const sanitizedEntity = await this.sanitizeOutput(entity, ctx);
 
-      return transformResponse(sanitize(entity));
+      return this.transformResponse(sanitizedEntity);
     },
 
     /**
@@ -61,9 +77,18 @@ const createCollectionTypeController = ({ service, sanitize, transformResponse }
 
       const { data, files } = parseBody(ctx);
 
-      const entity = await service.update(id, { params: query, data, files });
+      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);
     },
 
     /**
@@ -75,8 +100,10 @@ const createCollectionTypeController = ({ service, sanitize, transformResponse }
       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,26 +1,45 @@
 'use strict';
 
-const { sanitizeEntity, contentTypes } = 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,
+const getAuthFromKoaContext = getOr({}, 'state.auth');
+
+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, contentType, { auth });
     },
-    sanitize(data) {
-      return sanitizeEntity(data, { model: strapi.getModel(model.uid) });
+
+    sanitizeInput(data, ctx) {
+      const auth = getAuthFromKoaContext(ctx);
+
+      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,11 +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, sanitize, transformResponse }) => {
+const createSingleTypeController = ({ contentType }) => {
+  const { uid } = contentType;
+
   return {
     /**
      * Retrieve single type content
@@ -14,8 +19,11 @@ const createSingleTypeController = ({ service, sanitize, transformResponse }) =>
      */
     async find(ctx) {
       const { query } = ctx;
-      const entity = await service.find({ params: query });
-      return transformResponse(sanitize(entity));
+
+      const entity = await strapi.service(uid).find(query);
+      const sanitizedEntity = await this.sanitizeOutput(entity, ctx);
+
+      return this.transformResponse(sanitizedEntity);
     },
 
     /**
@@ -27,16 +35,27 @@ const createSingleTypeController = ({ service, sanitize, transformResponse }) =>
       const { query } = ctx.request;
       const { data, files } = parseBody(ctx);
 
-      const entity = await service.createOrUpdate({ params: query, data, files });
+      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)
+        .createOrUpdate({ ...query, data: sanitizedInputData, files });
+      const sanitizedEntity = await this.sanitizeOutput(entity, ctx);
+
+      return this.transformResponse(sanitizedEntity);
     },
 
     async delete(ctx) {
       const { query } = ctx;
 
-      const entity = await service.delete({ params: query });
-      return transformResponse(sanitize(entity));
+      const entity = await strapi.service(uid).delete(query);
+      const sanitizedEntity = await this.sanitizeOutput(entity, ctx);
+
+      return this.transformResponse(sanitizedEntity);
     },
   };
 };