@strapi/strapi 4.14.0-beta.0 → 4.15.0-alpha.0

package/lib/services/metrics/stringify-deep.js

@@ -1,22 +0,0 @@
-'use strict';
-
-const { map, mapValues, isObject, isArray, toString } = require('lodash/fp');
-
-/**
- * Stringify all non object valutes before send them
- * @param {object} obj
- * @returns {object}
- */
-const stringifyDeep = (value) => {
-  if (isArray(value)) {
-    return map(stringifyDeep, value);
-  }
-
-  if (isObject(value)) {
-    return mapValues(stringifyDeep, value);
-  }
-
-  return toString(value);
-};
-
-module.exports = stringifyDeep;

package/lib/services/request-context.js

@@ -1,17 +0,0 @@
-'use strict';
-
-const { AsyncLocalStorage } = require('async_hooks');
-
-const storage = new AsyncLocalStorage();
-
-const requestCtx = {
-  async run(store, cb) {
-    return storage.run(store, cb);
-  },
-
-  get() {
-    return storage.getStore();
-  },
-};
-
-module.exports = requestCtx;

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

@@ -1,14 +0,0 @@
-'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

@@ -1,36 +0,0 @@
-'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

@@ -1,141 +0,0 @@
-'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

@@ -1,16 +0,0 @@
-'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/http-server.js

@@ -1,64 +0,0 @@
-'use strict';
-
-const http = require('http');
-
-const createHTTPServer = (strapi, koaApp) => {
-  const connections = new Set();
-
-  // lazy creation of the request listener
-  let handler;
-  const listener = function handleRequest(req, res) {
-    if (!handler) {
-      handler = koaApp.callback();
-    }
-
-    return handler(req, res);
-  };
-
-  const server = http.createServer(listener);
-
-  server.on('connection', (connection) => {
-    connections.add(connection);
-
-    connection.on('close', () => {
-      connections.delete(connection);
-    });
-  });
-
-  // handle port in use cleanly
-  server.on('error', (err) => {
-    if (err.code === 'EADDRINUSE') {
-      return strapi.stopWithError(`The port ${err.port} is already used by another application.`);
-    }
-
-    strapi.log.error(err);
-  });
-
-  server.destroy = async () => {
-    for (const connection of connections) {
-      connection.destroy();
-
-      connections.delete(connection);
-    }
-
-    if (!server.listening) {
-      return;
-    }
-
-    return new Promise((resolve, reject) => {
-      server.close((error) => {
-        if (error) {
-          reject(error);
-        } else {
-          resolve();
-        }
-      });
-    });
-  };
-
-  return server;
-};
-
-module.exports = {
-  createHTTPServer,
-};

package/lib/services/server/index.js

@@ -1,129 +0,0 @@
-'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 requestCtx = require('../request-context');
-
-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'),
-    keys: strapi.config.get('server.app.keys'),
-  });
-
-  app.use((ctx, next) => requestCtx.run(ctx, () => next()));
-
-  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;
-    },
-
-    initRouting() {
-      registerAllRoutes(strapi);
-
-      return this;
-    },
-
-    async initMiddlewares() {
-      await registerApplicationMiddlewares(strapi);
-
-      return this;
-    },
-
-    listRoutes() {
-      const allRoutes = [...router.stack];
-
-      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

@@ -1,62 +0,0 @@
-'use strict';
-
-const { isNil, camelCase } = require('lodash/fp');
-const Koa = require('koa');
-const createError = require('http-errors');
-const delegate = require('delegates');
-const 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 responseCode(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 send(data, status = 200) {
-    this.status = status;
-    this.body = data;
-  };
-
-  app.response.created = function created(data) {
-    this.status = 201;
-    this.body = data;
-  };
-
-  app.response.deleted = function deleted(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, keys }) => {
-  const app = new Koa({ proxy });
-  app.keys = keys;
-
-  addCustomMethods(app);
-
-  return app;
-};
-
-module.exports = createKoaApp;

package/lib/services/server/middleware.js

@@ -1,132 +0,0 @@
-'use strict';
-
-const path = require('path');
-const { propOr, isArray, isNil } = require('lodash/fp');
-const { importDefault } = require('@strapi/utils');
-
-const getMiddlewareConfig = propOr([], 'config.middlewares');
-
-const instantiateMiddleware = (middlewareFactory, name, config, strapi) => {
-  try {
-    return middlewareFactory(config, { strapi });
-  } catch (e) {
-    throw new Error(`Middleware "${name}": ${e.message}`);
-  }
-};
-
-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: instantiateMiddleware(middlewareFactory, item, {}, strapi),
-      });
-
-      continue;
-    }
-
-    if (typeof item === 'object' && item !== null) {
-      const { name, resolve, config = {} } = item;
-
-      if (name) {
-        const middlewareFactory = strapi.middleware(name);
-        middlewares.push({
-          name,
-          handler: instantiateMiddleware(middlewareFactory, name, config, strapi),
-        });
-
-        continue;
-      }
-
-      if (resolve) {
-        const resolvedMiddlewareFactory = resolveCustomMiddleware(resolve, strapi);
-        middlewares.push({
-          name: resolve,
-          handler: instantiateMiddleware(resolvedMiddlewareFactory, item, 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.dist.root, resolve);
-    } else {
-      throw error;
-    }
-  }
-
-  try {
-    return importDefault(modulePath);
-  } catch (err) {
-    throw new Error(`Could not load middleware "${modulePath}".`);
-  }
-};
-
-module.exports = {
-  resolveRouteMiddlewares,
-  resolveMiddlewares,
-};

package/lib/services/server/policy.js

@@ -1,32 +0,0 @@
-'use strict';
-
-const { propOr } = require('lodash/fp');
-const { PolicyError } = 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 PolicyError();
-      }
-    }
-
-    await next();
-  };
-
-  return [policiesMiddleware];
-};
-
-module.exports = {
-  resolvePolicies,
-};