@strapi/strapi 4.0.0-next.9 → 4.0.0

package/lib/services/server/api.js

@@ -0,0 +1,36 @@
+'use strict';
+
+const Router = require('@koa/router');
+
+const { createRouteManager } = require('./routing');
+
+const createAPI = (strapi, opts = {}) => {
+  const { prefix, type } = opts;
+
+  const api = new Router({ prefix });
+
+  const routeManager = createRouteManager(strapi, { type });
+
+  return {
+    listRoutes() {
+      return [...api.stack];
+    },
+
+    use(fn) {
+      api.use(fn);
+      return this;
+    },
+
+    routes(routes) {
+      routeManager.addRoutes(routes, api);
+      return this;
+    },
+
+    mount(router) {
+      router.use(api.routes(), api.allowedMethods());
+      return this;
+    },
+  };
+};
+
+module.exports = { createAPI };

package/lib/services/server/compose-endpoint.js

@@ -0,0 +1,141 @@
+'use strict';
+
+const { has, toLower, castArray, trim, prop, isNil } = require('lodash/fp');
+const { UnauthorizedError, ForbiddenError } = require('@strapi/utils').errors;
+
+const compose = require('koa-compose');
+const { resolveRouteMiddlewares } = require('./middleware');
+const { resolvePolicies } = require('./policy');
+
+const getMethod = route => trim(toLower(route.method));
+const getPath = route => trim(route.path);
+
+const createRouteInfoMiddleware = routeInfo => (ctx, next) => {
+  const route = {
+    ...routeInfo,
+    config: routeInfo.config || {},
+  };
+
+  ctx.state.route = route;
+  return next();
+};
+
+const getAuthConfig = prop('config.auth');
+
+const createAuthorizeMiddleware = strapi => async (ctx, next) => {
+  const { auth, route } = ctx.state;
+
+  const authService = strapi.container.get('auth');
+
+  try {
+    await authService.verify(auth, getAuthConfig(route));
+
+    return next();
+  } catch (error) {
+    if (error instanceof UnauthorizedError) {
+      return ctx.unauthorized();
+    }
+
+    if (error instanceof ForbiddenError) {
+      return ctx.forbidden();
+    }
+
+    throw error;
+  }
+};
+
+const createAuthenticateMiddleware = strapi => async (ctx, next) => {
+  return strapi.container.get('auth').authenticate(ctx, next);
+};
+
+const returnBodyMiddleware = async (ctx, next) => {
+  const values = await next();
+
+  if (isNil(ctx.body) && !isNil(values)) {
+    ctx.body = values;
+  }
+};
+
+module.exports = strapi => {
+  const authenticate = createAuthenticateMiddleware(strapi);
+  const authorize = createAuthorizeMiddleware(strapi);
+
+  return (route, { router }) => {
+    try {
+      const method = getMethod(route);
+      const path = getPath(route);
+
+      const middlewares = resolveRouteMiddlewares(route, strapi);
+      const policies = resolvePolicies(route);
+
+      const action = getAction(route, strapi);
+
+      const routeHandler = compose([
+        createRouteInfoMiddleware(route),
+        authenticate,
+        authorize,
+        ...policies,
+        ...middlewares,
+        returnBodyMiddleware,
+        ...castArray(action),
+      ]);
+
+      router[method](path, routeHandler);
+    } catch (error) {
+      error.message = `Error creating endpoint ${route.method} ${route.path}: ${error.message}`;
+      throw error;
+    }
+  };
+};
+
+const getController = (name, { pluginName, apiName }, strapi) => {
+  let ctrl;
+
+  if (pluginName) {
+    if (pluginName === 'admin') {
+      ctrl = strapi.controller(`admin::${name}`);
+    } else {
+      ctrl = strapi.plugin(pluginName).controller(name);
+    }
+  } else if (apiName) {
+    ctrl = strapi.controller(`api::${apiName}.${name}`);
+  }
+
+  if (!ctrl) {
+    return strapi.controller(name);
+  }
+
+  return ctrl;
+};
+
+const extractHandlerParts = name => {
+  const controllerName = name.slice(0, name.lastIndexOf('.'));
+  const actionName = name.slice(name.lastIndexOf('.') + 1);
+
+  return { controllerName, actionName };
+};
+
+const getAction = (route, strapi) => {
+  const { handler, info = {} } = route;
+  const { pluginName, apiName, type } = info;
+
+  if (Array.isArray(handler) || typeof handler === 'function') {
+    return handler;
+  }
+
+  const { controllerName, actionName } = extractHandlerParts(trim(handler));
+
+  const controller = getController(controllerName, { pluginName, apiName }, strapi);
+
+  if (typeof controller[actionName] !== 'function') {
+    throw new Error(`Handler not found "${handler}"`);
+  }
+
+  if (has(Symbol.for('__type__'), controller[actionName])) {
+    controller[actionName][Symbol.for('__type__')].push(type);
+  } else {
+    controller[actionName][Symbol.for('__type__')] = [type];
+  }
+
+  return controller[actionName].bind(controller);
+};

package/lib/services/server/content-api.js

@@ -0,0 +1,16 @@
+'use strict';
+
+const { createAPI } = require('./api');
+
+const createContentAPI = strapi => {
+  const opts = {
+    prefix: strapi.config.get('api.rest.prefix', '/api'),
+    type: 'content-api',
+  };
+
+  return createAPI(strapi, opts);
+};
+
+module.exports = {
+  createContentAPI,
+};

package/lib/services/server/index.js

@@ -0,0 +1,127 @@
+'use strict';
+
+const Router = require('@koa/router');
+
+const { createHTTPServer } = require('./http-server');
+const { createRouteManager } = require('./routing');
+const { createAdminAPI } = require('./admin-api');
+const { createContentAPI } = require('./content-api');
+const registerAllRoutes = require('./register-routes');
+const registerApplicationMiddlewares = require('./register-middlewares');
+const createKoaApp = require('./koa');
+
+const healthCheck = async ctx => {
+  ctx.set('strapi', 'You are so French!');
+  ctx.status = 204;
+};
+
+/**
+ * @typedef Server
+ *
+ * @property {Koa} app
+ * @property {http.Server} app
+ */
+
+/**
+ *
+ * @param {Strapi} strapi
+ * @returns {Server}
+ */
+const createServer = strapi => {
+  const app = createKoaApp({ proxy: strapi.config.get('server.proxy') });
+
+  const router = new Router();
+
+  const routeManager = createRouteManager(strapi);
+
+  const httpServer = createHTTPServer(strapi, app);
+
+  const apis = {
+    'content-api': createContentAPI(strapi),
+    admin: createAdminAPI(strapi),
+  };
+
+  // init health check
+  router.all('/_health', healthCheck);
+
+  const state = {
+    mounted: false,
+  };
+
+  return {
+    app,
+    router,
+    httpServer,
+
+    api(name) {
+      return apis[name];
+    },
+
+    use(...args) {
+      app.use(...args);
+      return this;
+    },
+
+    routes(routes) {
+      if (routes.type) {
+        const api = apis[routes.type];
+        if (!api) {
+          throw new Error(`API ${routes.type} not found. Possible APIs are ${Object.keys(apis)}`);
+        }
+
+        apis[routes.type].routes(routes);
+        return this;
+      }
+
+      routeManager.addRoutes(routes, router);
+      return this;
+    },
+
+    mount() {
+      state.mounted = true;
+
+      Object.values(apis).forEach(api => api.mount(router));
+      app.use(router.routes()).use(router.allowedMethods());
+
+      return this;
+    },
+
+    async initRouting() {
+      await registerAllRoutes(strapi);
+
+      return this;
+    },
+
+    async initMiddlewares() {
+      await registerApplicationMiddlewares(strapi);
+
+      return this;
+    },
+
+    listRoutes() {
+      const allRoutes = [...router.stack];
+
+      Object.values(apis).forEach(api => {
+        allRoutes.push(...api.listRoutes());
+      });
+
+      return allRoutes;
+    },
+
+    listen(...args) {
+      if (!state.mounted) {
+        this.mount();
+      }
+
+      return httpServer.listen(...args);
+    },
+
+    async destroy() {
+      await httpServer.destroy();
+    },
+  };
+};
+
+module.exports = {
+  createServer,
+};

package/lib/services/server/koa.js

@@ -0,0 +1,64 @@
+'use strict';
+
+const { isNil, camelCase } = require('lodash/fp');
+const Koa = require('koa');
+const createError = require('http-errors');
+const delegate = require('delegates');
+var statuses = require('statuses');
+const { formatHttpError } = require('../errors');
+
+const addCustomMethods = app => {
+  const delegator = delegate(app.context, 'response');
+
+  /* errors */
+  statuses.codes
+    .filter(code => code >= 400 && code < 600)
+    .forEach(code => {
+      const name = statuses(code);
+      const camelCasedName = camelCase(name);
+      app.response[camelCasedName] = function(message, details = {}) {
+        const httpError = createError(code, message, { details });
+        const { status, body } = formatHttpError(httpError);
+        this.status = status;
+        this.body = body;
+      };
+      delegator.method(camelCasedName);
+    });
+
+  /* send, created, deleted */
+  app.response.send = function(data, status = 200) {
+    this.status = status;
+    this.body = data;
+  };
+
+  app.response.created = function(data) {
+    this.status = 201;
+    this.body = data;
+  };
+
+  app.response.deleted = function(data) {
+    if (isNil(data)) {
+      this.status = 204;
+    } else {
+      this.status = 200;
+      this.body = data;
+    }
+  };
+
+  delegator
+    .method('send')
+    .method('created')
+    .method('deleted');
+
+  return app;
+};
+
+const createKoaApp = ({ proxy }) => {
+  const app = new Koa({ proxy });
+
+  addCustomMethods(app);
+
+  return app;
+};
+
+module.exports = createKoaApp;

package/lib/services/server/middleware.js

@@ -0,0 +1,122 @@
+'use strict';
+
+const path = require('path');
+const { propOr, isArray, isNil } = require('lodash/fp');
+
+const getMiddlewareConfig = propOr([], 'config.middlewares');
+
+const resolveRouteMiddlewares = (route, strapi) => {
+  const middlewaresConfig = getMiddlewareConfig(route);
+
+  if (!isArray(middlewaresConfig)) {
+    throw new Error('Route middlewares config must be an array');
+  }
+
+  const middlewares = resolveMiddlewares(middlewaresConfig, strapi);
+
+  return middlewares.map(({ handler }) => handler);
+};
+
+/**
+ * Initialize every configured middlewares
+ * @param {MiddlewaresConfig} config
+ * @param {Strapi} strapi
+ * @returns {Middlewares}
+ */
+const resolveMiddlewares = (config, strapi) => {
+  const middlewares = [];
+
+  for (const item of config) {
+    if (typeof item === 'function') {
+      middlewares.push({
+        name: null,
+        handler: item,
+      });
+
+      continue;
+    }
+
+    if (typeof item === 'string') {
+      const middlewareFactory = strapi.middleware(item);
+
+      if (!middlewareFactory) {
+        throw new Error(`Middleware ${item} not found.`);
+      }
+
+      middlewares.push({
+        name: item,
+        handler: middlewareFactory({}, { strapi }),
+      });
+
+      continue;
+    }
+
+    if (typeof item === 'object' && item !== null) {
+      const { name, resolve, config = {} } = item;
+
+      if (name) {
+        const middlewareFactory = strapi.middleware(name);
+        middlewares.push({
+          name,
+          handler: middlewareFactory(config, { strapi }),
+        });
+
+        continue;
+      }
+
+      if (resolve) {
+        middlewares.push({
+          name: resolve,
+          handler: resolveCustomMiddleware(resolve, strapi)(config, { strapi }),
+        });
+
+        continue;
+      }
+
+      throw new Error('Invalid middleware configuration. Missing name or resolve properties.');
+    }
+
+    throw new Error(
+      'Middleware config must either be a string or an object {name?: string, resolve?: string, config: any}.'
+    );
+  }
+
+  middlewares.forEach(middleware => {
+    // NOTE: we replace null middlewares by a dumb one to avoid having to filter later on
+    if (isNil(middleware.handler)) {
+      middleware.handler = (_, next) => next();
+    }
+  });
+
+  return middlewares;
+};
+
+/**
+ * Resolve middleware from package name or path
+ * @param {string} resolve
+ * @param {Strapi} strapi
+ */
+const resolveCustomMiddleware = (resolve, strapi) => {
+  let modulePath;
+
+  try {
+    modulePath = require.resolve(resolve);
+  } catch (error) {
+    if (error.code === 'MODULE_NOT_FOUND') {
+      modulePath = path.resolve(strapi.dirs.root, resolve);
+    } else {
+      throw error;
+    }
+  }
+
+  try {
+    return require(modulePath);
+  } catch (err) {
+    throw new Error(`Could not load middleware "${modulePath}".`);
+  }
+};
+
+module.exports = {
+  resolveRouteMiddlewares,
+  resolveMiddlewares,
+};

package/lib/services/server/policy.js

@@ -0,0 +1,32 @@
+'use strict';
+
+const { propOr } = require('lodash/fp');
+const { ForbiddenError } = require('@strapi/utils').errors;
+const { policy: policyUtils } = require('@strapi/utils');
+
+const getPoliciesConfig = propOr([], 'config.policies');
+
+const resolvePolicies = route => {
+  const policiesConfig = getPoliciesConfig(route);
+  const resolvedPolicies = policyUtils.resolve(policiesConfig, route.info);
+
+  const policiesMiddleware = async (ctx, next) => {
+    const context = policyUtils.createPolicyContext('koa', ctx);
+
+    for (const { handler, config } of resolvedPolicies) {
+      const result = await handler(context, config, { strapi });
+
+      if (![true, undefined].includes(result)) {
+        throw new ForbiddenError('Policies failed.');
+      }
+    }
+
+    await next();
+  };
+
+  return [policiesMiddleware];
+};
+
+module.exports = {
+  resolvePolicies,
+};

package/lib/services/server/register-middlewares.js

@@ -0,0 +1,110 @@
+'use strict';
+
+const { yup } = require('@strapi/utils');
+
+const { resolveMiddlewares } = require('./middleware');
+
+/**
+ * @typedef {import('../../').Strapi} Strapi
+ * @typedef {Array<string|{name?: string, resolve?: string, config: any}>} MiddlewaresConfig
+ * @typedef {Array<{name: string, hanlder: Function}>} Middlewares
+ */
+
+const defaultConfig = [
+  'strapi::errors',
+  'strapi::security',
+  'strapi::cors',
+  'strapi::poweredBy',
+  'strapi::logger',
+  'strapi::query',
+  'strapi::body',
+  'strapi::favicon',
+  'strapi::public',
+];
+
+const requiredMiddlewares = [
+  'strapi::errors',
+  'strapi::security',
+  'strapi::cors',
+  'strapi::query',
+  'strapi::body',
+  'strapi::public',
+  'strapi::favicon',
+];
+
+const middlewareConfigSchema = yup.array().of(
+  yup.lazy(value => {
+    if (typeof value === 'string') {
+      return yup.string().required();
+    }
+
+    if (typeof value === 'object') {
+      return yup
+        .object({
+          name: yup.string(),
+          resolve: yup.string(),
+          config: yup.mixed(),
+        })
+        .required()
+        .noUnknown();
+    }
+
+    return yup.test(() => false);
+  })
+);
+
+/**
+ * Register middlewares in router
+ * @param {Strapi} strapi
+ */
+const registerApplicationMiddlewares = async strapi => {
+  const middlewareConfig = strapi.config.get('middlewares', defaultConfig);
+
+  await validateMiddlewareConfig(middlewareConfig);
+
+  const middlewares = await resolveMiddlewares(middlewareConfig, strapi);
+
+  checkRequiredMiddlewares(middlewares);
+
+  // NOTE: exclude middlewares that return nothing.
+  // this is used for middlewares that only extend the app only need to be added in certain conditions
+  for (const middleware of middlewares) {
+    strapi.server.use(middleware.handler);
+  }
+};
+
+/**
+ *
+ * @param {MiddlewaresConfig} config
+ */
+const validateMiddlewareConfig = async config => {
+  try {
+    await middlewareConfigSchema.validate(config, { strict: true, abortEarly: false });
+  } catch (error) {
+    throw new Error(
+      'Invalid middleware configuration. Expected Array<string|{name?: string, resolve?: string, config: any}.'
+    );
+  }
+};
+
+/**
+ * Check if some required middlewares are missing in configure middlewares
+ * @param {Middlewares} middlewares
+ */
+const checkRequiredMiddlewares = middlewares => {
+  const missingMiddlewares = requiredMiddlewares.filter(name => {
+    return middlewares.findIndex(mdl => mdl.name === name) === -1;
+  });
+
+  if (missingMiddlewares.length > 0) {
+    throw new Error(
+      `Missing required middlewares in configuration. Add the following middlewares: "${missingMiddlewares.join(
+        ', '
+      )}".`
+    );
+  }
+
+  return;
+};
+
+module.exports = registerApplicationMiddlewares;