@strapi/strapi 4.14.0-alpha.0 → 4.14.0

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

@@ -1,109 +0,0 @@
-'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::session',
-  '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(
-        ', '
-      )}".`
-    );
-  }
-};
-
-module.exports = registerApplicationMiddlewares;

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

@@ -1,105 +0,0 @@
-'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::`);
-
-  _.forEach(strapi.admin.routes, (router) => {
-    router.type = router.type || 'admin';
-    router.prefix = router.prefix || `/admin`;
-    router.routes.forEach((route) => {
-      generateRouteScope(route);
-      route.info = { pluginName: 'admin' };
-    });
-    strapi.server.routes(router);
-  });
-};
-
-/**
- * Register plugin routes
- * @param {import('../../').Strapi} strapi
- */
-const registerPluginRoutes = (strapi) => {
-  for (const pluginName of Object.keys(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 = 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 of Object.keys(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

@@ -1,105 +0,0 @@
-'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/dynamic-zones.js

@@ -1,13 +0,0 @@
-'use strict';
-
-const { map, values, sumBy, pipe, flatMap, propEq } = require('lodash/fp');
-
-const getNumberOfDynamicZones = () => {
-  return pipe(
-    map('attributes'),
-    flatMap(values),
-    sumBy(propEq('type', 'dynamiczone'))
-  )(strapi.contentTypes);
-};
-
-module.exports = getNumberOfDynamicZones;

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

@@ -1,79 +0,0 @@
-'use strict';
-
-const _ = require('lodash');
-
-/**
- * Upload files and link them to an entity
- * @param {string} uid model uid
- * @param {object} entity entity created
- * @param {object} files files to upload
- * @returns {void}
- */
-module.exports = async (uid, entity, files) => {
-  const modelDef = strapi.getModel(uid);
-
-  if (!_.has(strapi.plugins, 'upload')) {
-    return;
-  }
-
-  const uploadService = strapi.plugin('upload').service('upload');
-
-  const findModelFromUploadPath = (path) => {
-    if (path.length === 0) {
-      return uid;
-    }
-
-    const currentPath = [];
-    let tmpModel = modelDef;
-    let modelUID = uid;
-
-    for (let i = 0; i < path.length; i += 1) {
-      if (!tmpModel) return {};
-      const part = path[i];
-      const attr = tmpModel.attributes[part];
-
-      currentPath.push(part);
-
-      // ignore array indexes => handled in the dynamic zone section
-      if (_.isFinite(_.toNumber(path[i]))) {
-        continue;
-      }
-
-      if (!attr) return {};
-
-      if (attr.type === 'component') {
-        modelUID = attr.component;
-        tmpModel = strapi.components[attr.component];
-      } else if (attr.type === 'dynamiczone') {
-        const entryIdx = path[i + 1]; // get component index
-        const value = _.get(entity, [...currentPath, entryIdx]);
-
-        if (!value) return {};
-
-        modelUID = value.__component; // get component type
-        tmpModel = strapi.components[modelUID];
-      } else if (attr.type === 'relation') {
-        modelUID = attr.target;
-        tmpModel = strapi.getModel(modelUID);
-      } else {
-        return;
-      }
-    }
-
-    return modelUID;
-  };
-
-  const doUpload = async (key, files) => {
-    const parts = key.split('.');
-    const [path, field] = [_.initial(parts), _.last(parts)];
-
-    const modelUID = findModelFromUploadPath(path);
-
-    if (modelUID) {
-      const id = _.get(entity, path.concat('id'));
-      return uploadService.uploadToEntity({ id, model: modelUID, field }, files);
-    }
-  };
-
-  await Promise.all(Object.keys(files).map((key) => doUpload(key, files[key])));
-};

package/lib/services/webhook-runner.js

@@ -1,156 +0,0 @@
-/**
- * The event hub is Strapi's event control center.
- */
-
-'use strict';
-
-const debug = require('debug')('strapi:webhook');
-const _ = require('lodash');
-
-const WorkerQueue = require('./worker-queue');
-
-const defaultConfiguration = {
-  defaultHeaders: {},
-};
-
-class WebhookRunner {
-  constructor({ eventHub, logger, configuration = {}, fetch }) {
-    debug('Initialized webhook runner');
-    this.eventHub = eventHub;
-    this.logger = logger;
-    this.webhooksMap = new Map();
-    this.listeners = new Map();
-    this.fetch = fetch;
-
-    if (typeof configuration !== 'object') {
-      throw new Error(
-        'Invalid configuration provided to the webhookRunner.\nCheck your server.json -> webhooks configuration'
-      );
-    }
-
-    this.config = _.merge(defaultConfiguration, configuration);
-
-    this.queue = new WorkerQueue({ logger, concurrency: 5 });
-    this.queue.subscribe(this.executeListener.bind(this));
-  }
-
-  deleteListener(event) {
-    debug(`Deleting listener for event '${event}'`);
-    if (this.listeners.has(event)) {
-      const fn = this.listeners.get(event);
-
-      this.eventHub.off(event, fn);
-      this.listeners.delete(event);
-    }
-  }
-
-  createListener(event) {
-    debug(`Creating listener for event '${event}'`);
-    if (this.listeners.has(event)) {
-      this.logger.error(
-        `The webhook runner is already listening for the event '${event}'. Did you mean to call .register() ?`
-      );
-    }
-
-    const listen = (info) => {
-      this.queue.enqueue({ event, info });
-    };
-
-    this.listeners.set(event, listen);
-    this.eventHub.on(event, listen);
-  }
-
-  async executeListener({ event, info }) {
-    debug(`Executing webhook for event '${event}'`);
-    const webhooks = this.webhooksMap.get(event) || [];
-    const activeWebhooks = webhooks.filter((webhook) => webhook.isEnabled === true);
-
-    for (const webhook of activeWebhooks) {
-      await this.run(webhook, event, info).catch((error) => {
-        this.logger.error('Error running webhook');
-        this.logger.error(error);
-      });
-    }
-  }
-
-  run(webhook, event, info = {}) {
-    const { url, headers } = webhook;
-
-    return this.fetch(url, {
-      method: 'post',
-      body: JSON.stringify({
-        event,
-        createdAt: new Date(),
-        ...info,
-      }),
-      headers: {
-        ...this.config.defaultHeaders,
-        ...headers,
-        'X-Strapi-Event': event,
-        'Content-Type': 'application/json',
-      },
-      timeout: 10000,
-    })
-      .then(async (res) => {
-        if (res.ok) {
-          return {
-            statusCode: res.status,
-          };
-        }
-
-        return {
-          statusCode: res.status,
-          message: await res.text(),
-        };
-      })
-      .catch((err) => {
-        return {
-          statusCode: 500,
-          message: err.message,
-        };
-      });
-  }
-
-  add(webhook) {
-    debug(`Registering webhook '${webhook.id}'`);
-    const { events } = webhook;
-
-    events.forEach((event) => {
-      if (this.webhooksMap.has(event)) {
-        this.webhooksMap.get(event).push(webhook);
-      } else {
-        this.webhooksMap.set(event, [webhook]);
-        this.createListener(event);
-      }
-    });
-  }
-
-  update(webhook) {
-    debug(`Refreshing webhook '${webhook.id}'`);
-    this.remove(webhook);
-    this.add(webhook);
-  }
-
-  remove(webhook) {
-    debug(`Unregistering webhook '${webhook.id}'`);
-
-    this.webhooksMap.forEach((webhooks, event) => {
-      const filteredWebhooks = webhooks.filter((value) => value.id !== webhook.id);
-
-      // Cleanup hanging listeners
-      if (filteredWebhooks.length === 0) {
-        this.webhooksMap.delete(event);
-        this.deleteListener(event);
-      } else {
-        this.webhooksMap.set(event, filteredWebhooks);
-      }
-    });
-  }
-}
-
-/**
- * Expose a factory function instead of the class
- */
-module.exports = function createWebhookRunner(opts) {
-  return new WebhookRunner(opts);
-};

package/lib/services/webhook-store.js

@@ -1,120 +0,0 @@
-/**
- * Webhook store is the implementation of webhook storage over the core_store
- */
-
-'use strict';
-
-const { mapAsync } = require('@strapi/utils');
-const { ValidationError } = require('@strapi/utils').errors;
-
-const webhookModel = {
-  uid: 'webhook',
-  collectionName: 'strapi_webhooks',
-  attributes: {
-    name: {
-      type: 'string',
-    },
-    url: {
-      type: 'text',
-    },
-    headers: {
-      type: 'json',
-    },
-    events: {
-      type: 'json',
-    },
-    enabled: {
-      type: 'boolean',
-    },
-  },
-};
-
-const toDBObject = (data) => {
-  return {
-    name: data.name,
-    url: data.url,
-    headers: data.headers,
-    events: data.events,
-    enabled: data.isEnabled,
-  };
-};
-
-const fromDBObject = (row) => {
-  return {
-    id: row.id,
-    name: row.name,
-    url: row.url,
-    headers: row.headers,
-    events: row.events,
-    isEnabled: row.enabled,
-  };
-};
-
-const webhookEventValidator = async (allowedEvents, events) => {
-  const allowedValues = Array.from(allowedEvents.values());
-
-  await mapAsync(events, (event) => {
-    if (allowedValues.includes(event)) {
-      return;
-    }
-
-    throw new ValidationError(`Webhook event ${event} is not supported`);
-  });
-};
-
-const createWebhookStore = ({ db }) => {
-  const webhookQueries = db.query('webhook');
-
-  return {
-    allowedEvents: new Map([]),
-    addAllowedEvent(key, value) {
-      this.allowedEvents.set(key, value);
-    },
-    removeAllowedEvent(key) {
-      this.allowedEvents.delete(key);
-    },
-    listAllowedEvents() {
-      return Array.from(this.allowedEvents.keys());
-    },
-    getAllowedEvent(key) {
-      return this.allowedEvents.get(key);
-    },
-    async findWebhooks() {
-      const results = await webhookQueries.findMany();
-
-      return results.map(fromDBObject);
-    },
-    async findWebhook(id) {
-      const result = await webhookQueries.findOne({ where: { id } });
-      return result ? fromDBObject(result) : null;
-    },
-    async createWebhook(data) {
-      await webhookEventValidator(this.allowedEvents, data.events);
-
-      return webhookQueries
-        .create({
-          data: toDBObject({ ...data, isEnabled: true }),
-        })
-        .then(fromDBObject);
-    },
-    async updateWebhook(id, data) {
-      await webhookEventValidator(this.allowedEvents, data.events);
-
-      const webhook = await webhookQueries.update({
-        where: { id },
-        data: toDBObject(data),
-      });
-
-      return webhook ? fromDBObject(webhook) : null;
-    },
-    async deleteWebhook(id) {
-      const webhook = await webhookQueries.delete({ where: { id } });
-      return webhook ? fromDBObject(webhook) : null;
-    },
-  };
-};
-
-module.exports = {
-  webhookModel,
-  createWebhookStore,
-};