@strapi/strapi 4.0.0-next.6 → 4.0.0

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;

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

@@ -0,0 +1,106 @@
+'use strict';
+
+const _ = require('lodash');
+
+const createRouteScopeGenerator = namespace => route => {
+  const prefix = namespace.endsWith('::') ? namespace : `${namespace}.`;
+
+  if (typeof route.handler === 'string') {
+    _.defaultsDeep(route, {
+      config: {
+        auth: {
+          scope: [`${route.handler.startsWith(prefix) ? '' : prefix}${route.handler}`],
+        },
+      },
+    });
+  }
+};
+
+/**
+ * Register all routes
+ * @param {import('../../').Strapi} strapi
+ */
+module.exports = strapi => {
+  registerAdminRoutes(strapi);
+  registerAPIRoutes(strapi);
+  registerPluginRoutes(strapi);
+};
+
+/**
+ * Register admin routes
+ * @param {import('../../').Strapi} strapi
+ */
+const registerAdminRoutes = strapi => {
+  const generateRouteScope = createRouteScopeGenerator(`admin::`);
+
+  strapi.admin.routes.forEach(route => {
+    generateRouteScope(route);
+    route.info = { pluginName: 'admin' };
+  });
+
+  strapi.server.routes({
+    type: 'admin',
+    prefix: '/admin',
+    routes: strapi.admin.routes,
+  });
+};
+
+/**
+ * Register plugin routes
+ * @param {import('../../').Strapi} strapi
+ */
+const registerPluginRoutes = strapi => {
+  for (const pluginName in strapi.plugins) {
+    const plugin = strapi.plugins[pluginName];
+
+    const generateRouteScope = createRouteScopeGenerator(`plugin::${pluginName}`);
+
+    if (Array.isArray(plugin.routes)) {
+      plugin.routes.forEach(route => {
+        generateRouteScope(route);
+        route.info = { pluginName };
+      });
+
+      strapi.server.routes({
+        type: 'admin',
+        prefix: `/${pluginName}`,
+        routes: plugin.routes,
+      });
+    } else {
+      _.forEach(plugin.routes, router => {
+        router.type = router.type || 'admin';
+        router.prefix = `/${pluginName}`;
+        router.routes.forEach(route => {
+          generateRouteScope(route);
+          route.info = { pluginName };
+        });
+
+        strapi.server.routes(router);
+      });
+    }
+  }
+};
+
+/**
+ * Register api routes
+ * @param {import('../../').Strapi} strapi
+ */
+const registerAPIRoutes = strapi => {
+  for (const apiName in strapi.api) {
+    const api = strapi.api[apiName];
+
+    const generateRouteScope = createRouteScopeGenerator(`api::${apiName}`);
+
+    _.forEach(api.routes, router => {
+      // TODO: remove once auth setup
+      // pass meta down to compose endpoint
+      router.type = 'content-api';
+      router.routes.forEach(route => {
+        generateRouteScope(route);
+        route.info = { apiName };
+      });
+
+      return strapi.server.routes(router);
+    });
+  }
+};

package/lib/services/server/routing.js

@@ -0,0 +1,120 @@
+'use strict';
+
+const Router = require('@koa/router');
+const _ = require('lodash');
+const { has } = require('lodash/fp');
+const { yup } = require('@strapi/utils');
+
+const createEndpointComposer = require('./compose-endpoint');
+
+const policyOrMiddlewareSchema = yup.lazy(value => {
+  if (typeof value === 'string') {
+    return yup.string().required();
+  }
+
+  if (typeof value === 'function') {
+    return yup.mixed().isFunction();
+  }
+
+  return yup.object({
+    name: yup.string().required(),
+    options: yup.object().notRequired(), // any options
+  });
+});
+
+const routeSchema = yup.object({
+  method: yup
+    .string()
+    .oneOf(['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'ALL'])
+    .required(),
+  path: yup.string().required(),
+  handler: yup.lazy(value => {
+    if (typeof value === 'string') {
+      return yup.string().required();
+    }
+
+    if (Array.isArray(value)) {
+      return yup.array().required();
+    }
+
+    return yup
+      .mixed()
+      .isFunction()
+      .required();
+  }),
+  config: yup
+    .object({
+      auth: yup.lazy(value => {
+        if (value === false) {
+          return yup.boolean().required();
+        }
+
+        return yup.object({
+          scope: yup
+            .array()
+            .of(yup.string())
+            .required(),
+        });
+      }),
+      policies: yup
+        .array()
+        .of(policyOrMiddlewareSchema)
+        .notRequired(),
+      middlewares: yup
+        .array()
+        .of(policyOrMiddlewareSchema)
+        .notRequired(),
+    })
+    .notRequired(),
+});
+
+const validateRouteConfig = routeConfig => {
+  try {
+    return routeSchema.validateSync(routeConfig, {
+      strict: true,
+      abortEarly: false,
+      stripUnknown: true,
+    });
+  } catch (error) {
+    throw new Error('Invalid route config', error.message);
+  }
+};
+
+const createRouteManager = (strapi, opts = {}) => {
+  const { type } = opts;
+
+  const composeEndpoint = createEndpointComposer(strapi);
+
+  const createRoute = (route, router) => {
+    validateRouteConfig(route);
+
+    // NOTE: the router type is used to tag controller actions and for authentication / authorization so we need to pass this info down to the route level
+    _.set(route, 'info.type', type || 'admin');
+
+    composeEndpoint(route, { router });
+  };
+
+  const addRoutes = (routes, router) => {
+    if (Array.isArray(routes)) {
+      routes.forEach(route => createRoute(route, router));
+    } else if (routes.routes) {
+      const subRouter = new Router({ prefix: routes.prefix });
+
+      routes.routes.forEach(route => {
+        const hasPrefix = has('prefix', route.config);
+        createRoute(route, hasPrefix ? router : subRouter);
+      });
+
+      return router.use(subRouter.routes(), subRouter.allowedMethods());
+    }
+  };
+
+  return {
+    addRoutes,
+  };
+};
+
+module.exports = {
+  validateRouteConfig,
+  createRouteManager,
+};

package/lib/services/utils/upload-files.js

@@ -16,7 +16,7 @@ module.exports = async (uid, entity, files) => {
     return;
   }
 
-  const uploadService = strapi.plugins.upload.services.upload;
+  const uploadService = strapi.plugin('upload').service('upload');
 
   const findModelFromUploadPath = path => {
     if (path.length === 0) {

package/lib/services/webhook-runner.js

@@ -79,7 +79,7 @@ class WebhookRunner {
       method: 'post',
       body: JSON.stringify({
         event,
-        created_at: new Date(),
+        createdAt: new Date(),
         ...info,
       }),
       headers: {

package/lib/utils/ee.js

@@ -78,7 +78,7 @@ module.exports = ({ dir, logger = noLog }) => {
 };
 
 Object.defineProperty(module.exports, 'licenseInfo', {
-  get: () => {
+  get() {
     mustHaveKey('licenseInfo');
     return internals.licenseInfo;
   },
@@ -87,7 +87,7 @@ Object.defineProperty(module.exports, 'licenseInfo', {
 });
 
 Object.defineProperty(module.exports, 'isEE', {
-  get: () => {
+  get() {
     mustHaveKey('isEE');
     return internals.isEE;
   },
@@ -96,7 +96,7 @@ Object.defineProperty(module.exports, 'isEE', {
 });
 
 Object.defineProperty(module.exports, 'features', {
-  get: () => {
+  get() {
     mustHaveKey('licenseInfo');
 
     const { type: licenseType } = module.exports.licenseInfo;

package/lib/utils/get-dirs.js

@@ -0,0 +1,17 @@
+'use strict';
+
+const { join } = require('path');
+
+const getDirs = root => ({
+  root,
+  src: join(root, 'src'),
+  api: join(root, 'src', 'api'),
+  components: join(root, 'src', 'components'),
+  extensions: join(root, 'src', 'extensions'),
+  policies: join(root, 'src', 'policies'),
+  middlewares: join(root, 'src', 'middlewares'),
+  config: join(root, 'config'),
+  public: join(root, 'public'),
+});
+
+module.exports = getDirs;

package/lib/utils/index.js

@@ -2,8 +2,10 @@
 
 const openBrowser = require('./open-browser');
 const isInitialized = require('./is-initialized');
+const getDirs = require('./get-dirs');
 
 module.exports = {
   isInitialized,
   openBrowser,
+  getDirs,
 };

package/lib/utils/is-initialized.js

@@ -14,7 +14,7 @@ module.exports = async function isInitialized(strapi) {
     }
 
     // test if there is at least one admin
-    const anyAdministrator = await strapi.query('strapi::user').findOne({ select: ['id'] });
+    const anyAdministrator = await strapi.query('admin::user').findOne({ select: ['id'] });
 
     return !isNil(anyAdministrator);
   } catch (err) {

package/lib/utils/run-checks.js

@@ -2,7 +2,6 @@
 
 const path = require('path');
 const fs = require('fs-extra');
-const _ = require('lodash');
 
 const requiredPaths = ['api', 'extensions', 'plugins', 'config', 'public'];
 const checkFoldersExist = ({ appPath }) => {
@@ -18,20 +17,6 @@ const checkFoldersExist = ({ appPath }) => {
   }
 };
 
-const checkPluginsConflicts = ({ appPath, installedPlugins }) => {
-  const localPluginNames = fs.readdirSync(path.resolve(appPath, 'plugins'));
-  const pluginsIntersection = _.intersection(localPluginNames, installedPlugins);
-
-  if (pluginsIntersection.length > 0) {
-    throw new Error(
-      `You have some local plugins with the same name as npm installed plugins:\n${pluginsIntersection
-        .map(p => `- ${p}`)
-        .join('\n')}`
-    );
-  }
-};
-
 module.exports = config => {
   checkFoldersExist(config);
-  checkPluginsConflicts(config);
 };

package/lib/utils/signals.js

@@ -0,0 +1,24 @@
+'use strict';
+
+const destroyOnSignal = strapi => {
+  let signalReceived = false;
+
+  // For unknown reasons, we receive signals 2 times.
+  // As a temporary fix, we ignore the signals received after the first one.
+
+  const terminateStrapi = async () => {
+    if (!signalReceived) {
+      signalReceived = true;
+      await strapi.destroy();
+      process.exit();
+    }
+  };
+
+  ['SIGTERM', 'SIGINT'].forEach(signal => {
+    process.on(signal, terminateStrapi);
+  });
+};
+
+module.exports = {
+  destroyOnSignal,
+};

package/lib/utils/startup-logger.js

@@ -72,7 +72,7 @@ module.exports = app => {
       console.log();
     },
 
-    logStartupMessage(isInitialized) {
+    logStartupMessage({ isInitialized } = {}) {
       // Should the startup message be displayed?
       const hideStartupMessage = process.env.STRAPI_HIDE_STARTUP_MESSAGE
         ? process.env.STRAPI_HIDE_STARTUP_MESSAGE === 'true'
@@ -82,7 +82,7 @@ module.exports = app => {
         if (!isInitialized) {
           this.logFirstStartupMessage();
         } else {
-          this.logStartupMessage();
+          this.logDefaultStartupMessage();
         }
       }
     },

package/lib/utils/update-notifier/index.js

@@ -27,7 +27,7 @@ const geUpdatetMessage = (newVersion, currentVersion) => {
 
   return `
 A new version of Strapi is available ${currentVersionLog} → ${newVersionLog}
-Check out the new the releases at: ${releaseLink}
+Check out the new releases at: ${releaseLink}
 `.trim();
 };
 
@@ -38,7 +38,7 @@ const createUpdateNotifier = strapi => {
     config = new Configstore(
       pkg.name,
       {},
-      { configPath: path.join(strapi.dir, '.strapi-updater.json') }
+      { configPath: path.join(strapi.dirs.root, '.strapi-updater.json') }
     );
   } catch {
     // we don't have write access to the file system
@@ -67,6 +67,7 @@ const createUpdateNotifier = strapi => {
     const now = Date.now();
     const latestVersion = config.get('latest');
     const lastNotification = config.get('lastNotification') || 0;
+
     if (
       !process.stdout.isTTY ||
       lastNotification + notifInterval > now ||