@strapi/strapi 4.0.0-next.6 → 4.0.0

package/lib/services/errors.js

@@ -0,0 +1,77 @@
+'use strict';
+
+const createError = require('http-errors');
+const {
+  NotFoundError,
+  UnauthorizedError,
+  ForbiddenError,
+  PayloadTooLargeError,
+} = require('@strapi/utils').errors;
+
+const mapErrorsAndStatus = [
+  {
+    classError: UnauthorizedError,
+    status: 401,
+  },
+  {
+    classError: ForbiddenError,
+    status: 403,
+  },
+  {
+    classError: NotFoundError,
+    status: 404,
+  },
+  {
+    classError: PayloadTooLargeError,
+    status: 413,
+  },
+];
+
+const formatApplicationError = error => {
+  const errorAndStatus = mapErrorsAndStatus.find(pair => error instanceof pair.classError);
+  const status = errorAndStatus ? errorAndStatus.status : 400;
+
+  return {
+    status,
+    body: {
+      data: null,
+      error: {
+        status,
+        name: error.name,
+        message: error.message,
+        details: error.details,
+      },
+    },
+  };
+};
+
+const formatHttpError = error => {
+  return {
+    status: error.status,
+    body: {
+      data: null,
+      error: {
+        status: error.status,
+        name: error.name,
+        message: error.message,
+        details: error.details,
+      },
+    },
+  };
+};
+
+const formatInternalError = error => {
+  const httpError = createError(error);
+
+  if (httpError.expose) {
+    return formatHttpError(httpError);
+  }
+
+  return formatHttpError(createError(httpError.status || 500));
+};
+
+module.exports = {
+  formatApplicationError,
+  formatHttpError,
+  formatInternalError,
+};

package/lib/{core → services}/fs.js

@@ -10,9 +10,9 @@ module.exports = strapi => {
   function normalizePath(optPath) {
     const filePath = Array.isArray(optPath) ? optPath.join('/') : optPath;
 
-    const normalizedPath = path.normalize(filePath).replace(/^(\/?\.\.?)+/, '');
+    const normalizedPath = path.normalize(filePath).replace(/^\/?(\.\/|\.\.\/)+/, '');
 
-    return path.join(strapi.dir, normalizedPath);
+    return path.join(strapi.dirs.root, normalizedPath);
   }
 
   const strapiFS = {
@@ -44,6 +44,14 @@ module.exports = strapi => {
       const removePath = normalizePath(optPath);
       return fse.remove(removePath);
     },
+
+    /**
+     * Appends a file in strapi app
+     */
+    appendFile(optPath, data) {
+      const writePath = normalizePath(optPath);
+      return fse.appendFileSync(writePath, data);
+    },
   };
 
   return strapiFS;

package/lib/services/metrics/index.js

@@ -1,7 +1,7 @@
 'use strict';
 /**
  * Strapi telemetry package.
- * You can learn more at https://strapi.io/documentation/developer-docs/latest/getting-started/usage-information.html
+ * You can learn more at https://docs.strapi.io/developer-docs/latest/getting-started/usage-information.html
  */
 
 const crypto = require('crypto');
@@ -23,49 +23,51 @@ const LIMITED_EVENTS = [
 ];
 
 const createTelemetryInstance = strapi => {
-  const { uuid } = strapi.config;
+  const uuid = strapi.config.get('uuid');
   const isDisabled = !uuid || isTruthy(process.env.STRAPI_TELEMETRY_DISABLED);
 
   const crons = [];
   const sender = createSender(strapi);
   const sendEvent = wrapWithRateLimit(sender, { limitedEvents: LIMITED_EVENTS });
 
-  if (!isDisabled) {
-    const pingCron = scheduleJob('0 0 12 * * *', () => sendEvent('ping'));
-    crons.push(pingCron);
-
-    strapi.app.use(createMiddleware({ sendEvent }));
-  }
+  return {
+    register() {
+      if (!isDisabled) {
+        const pingCron = scheduleJob('0 0 12 * * *', () => sendEvent('ping'));
+        crons.push(pingCron);
 
-  if (strapi.EE === true && ee.isEE === true) {
-    const pingDisabled =
-      isTruthy(process.env.STRAPI_LICENSE_PING_DISABLED) && ee.licenseInfo.type === 'gold';
-
-    const sendLicenseCheck = () => {
-      return sendEvent(
-        'didCheckLicense',
-        {
-          licenseInfo: {
-            ...ee.licenseInfo,
-            projectHash: hashProject(strapi),
-            dependencyHash: hashDep(strapi),
-          },
-        },
-        {
-          headers: { 'x-strapi-project': 'enterprise' },
+        strapi.server.use(createMiddleware({ sendEvent }));
+      }
+    },
+    bootstrap() {
+      if (strapi.EE === true && ee.isEE === true) {
+        const pingDisabled =
+          isTruthy(process.env.STRAPI_LICENSE_PING_DISABLED) && ee.licenseInfo.type === 'gold';
+
+        const sendLicenseCheck = () => {
+          return sendEvent(
+            'didCheckLicense',
+            {
+              licenseInfo: {
+                ...ee.licenseInfo,
+                projectHash: hashProject(strapi),
+                dependencyHash: hashDep(strapi),
+              },
+            },
+            {
+              headers: { 'x-strapi-project': 'enterprise' },
+            }
+          );
+        };
+
+        if (!pingDisabled) {
+          const licenseCron = scheduleJob('0 0 0 * * 7', () => sendLicenseCheck());
+          crons.push(licenseCron);
+
+          sendLicenseCheck();
         }
-      );
-    };
-
-    if (!pingDisabled) {
-      const licenseCron = scheduleJob('0 0 0 * * 7', () => sendLicenseCheck());
-      crons.push(licenseCron);
-
-      sendLicenseCheck();
-    }
-  }
-
-  return {
+      }
+    },
     destroy() {
       // clear open handles
       crons.forEach(cron => cron.cancel());
@@ -83,11 +85,12 @@ const hash = str =>
     .update(str)
     .digest('hex');
 
-const hashProject = strapi => hash(`${strapi.config.info.name}${strapi.config.info.description}`);
+const hashProject = strapi =>
+  hash(`${strapi.config.get('info.name')}${strapi.config.get('info.description')}`);
 
 const hashDep = strapi => {
   const depStr = JSON.stringify(strapi.config.info.dependencies);
-  const readmePath = path.join(strapi.dir, 'README.md');
+  const readmePath = path.join(strapi.dirs.root, 'README.md');
 
   try {
     if (fs.existsSync(readmePath)) {

package/lib/services/metrics/sender.js

@@ -44,8 +44,8 @@ module.exports = strapi => {
     nodeVersion: process.version,
     docker: process.env.DOCKER || isDocker(),
     isCI: ciEnv.isCI,
-    version: strapi.config.info.strapi,
-    strapiVersion: strapi.config.info.strapi,
+    version: strapi.config.get('info.strapi'),
+    strapiVersion: strapi.config.get('info.strapi'),
     projectType: isEE ? 'Enterprise' : 'Community',
   };
 

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

@@ -0,0 +1,14 @@
+'use strict';
+
+const { createAPI } = require('./api');
+
+const createAdminAPI = strapi => {
+  const opts = {
+    prefix: '', // '/admin';
+    type: 'admin',
+  };
+
+  return createAPI(strapi, opts);
+};
+
+module.exports = { createAdminAPI };

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;