@strapi/strapi 4.0.0-next.7 → 4.0.1

package/lib/core/loaders/bootstrap.js

@@ -1,176 +0,0 @@
-'use strict';
-
-const _ = require('lodash');
-const { toLower, kebabCase } = require('lodash/fp');
-const { getConfigUrls } = require('@strapi/utils');
-const pluralize = require('pluralize');
-const { createContentType } = require('../domain/content-type');
-
-const { createCoreApi } = require('../../core-api');
-
-// TODO: function to be moved next to where the api will be loaded
-const validateContentTypesUnicity = schemas => {
-  const names = [];
-  schemas.forEach(schema => {
-    if (schema.info.singularName) {
-      const singularName = kebabCase(schema.info.singularName);
-      if (names.includes(singularName)) {
-        throw new Error(`The singular name "${schema.info.singularName}" should be unique`);
-      }
-      names.push(singularName);
-    }
-    if (schema.info.pluralName) {
-      const pluralName = kebabCase(schema.info.pluralName);
-      if (names.includes(pluralName)) {
-        throw new Error(`The plural name "${schema.info.pluralName}" should be unique`);
-      }
-      names.push(pluralName);
-    }
-  });
-};
-
-module.exports = function(strapi) {
-  strapi.contentTypes = {};
-
-  // validate Content-Types unicity
-  const allApisSchemas = Object.values(strapi.api).flatMap(api => Object.values(api.models));
-  validateContentTypesUnicity(allApisSchemas);
-
-  // TODO: to change with new loading system
-  // Register api content types
-  for (const apiName in strapi.api) {
-    const api = strapi.api[apiName];
-
-    const v4ContentTypes = _.mapValues(api.models, (model, modelName) => {
-      model.info.displayName = model.info.displayName || model.info.name;
-      model.info.singularName = model.info.singularName || modelName;
-      model.info.pluralName = model.info.pluralName || pluralize(modelName);
-
-      return {
-        schema: model,
-        actions: {},
-        lifecycles: {},
-      };
-    });
-
-    strapi.container.get('content-types').add(`api::${apiName}`, v4ContentTypes);
-  }
-
-  // TODO: remove v3
-  // Set models.
-  strapi.models = {};
-  for (const apiName in strapi.api) {
-    const api = strapi.api[apiName];
-    for (let modelName in api.models) {
-      let model = api.models[modelName];
-      const contentType = strapi.container
-        .get('content-types')
-        .get(`api::${apiName}.${model.info.singularName}`);
-      Object.assign(model, contentType.schema);
-      strapi.contentTypes[model.uid] = contentType.schema;
-
-      strapi.models[modelName] = model;
-    }
-  }
-
-  // set default services and default controllers
-  for (const apiName in strapi.api) {
-    const api = strapi.api[apiName];
-    for (const modelName in api.models) {
-      const model = api.models[modelName];
-      const { service, controller } = createCoreApi({ model, api, strapi });
-      _.set(strapi.api[apiName], ['services', modelName], service);
-      _.set(strapi.api[apiName], ['controllers', modelName], controller);
-    }
-  }
-
-  // Set user's controllers.
-  strapi.controllers = Object.keys(strapi.api || []).reduce((acc, apiName) => {
-    strapi.container.get('controllers').add(`api::${apiName}`, strapi.api[apiName].controllers);
-    for (let controllerName in strapi.api[apiName].controllers) {
-      let controller = strapi.api[apiName].controllers[controllerName];
-      acc[controllerName] = controller;
-    }
-
-    return acc;
-  }, {});
-
-  // Set user's services.
-  strapi.services = Object.keys(strapi.api || []).reduce((acc, apiName) => {
-    strapi.container.get('services').add(`api::${apiName}`, strapi.api[apiName].services);
-    for (let serviceName in strapi.api[apiName].services) {
-      acc[serviceName] = strapi.api[apiName].services[serviceName];
-    }
-
-    return acc;
-  }, {});
-
-  // Set routes.
-  strapi.config.routes = Object.keys(strapi.api || []).reduce((acc, key) => {
-    return acc.concat(_.get(strapi.api[key], 'config.routes') || {});
-  }, []);
-
-  // Init admin models.
-  Object.keys(strapi.admin.models || []).forEach(modelName => {
-    let model = strapi.admin.models[modelName];
-    // mutate model
-    const ct = { schema: model, actions: {}, lifecycles: {} };
-    ct.schema.info.displayName = model.info.name;
-    ct.schema.info.singularName = modelName;
-    ct.schema.info.pluralName = pluralize(modelName);
-
-    const createdContentType = createContentType(`strapi::${ct.schema.info.singularName}`, ct);
-
-    Object.assign(model, createdContentType.schema);
-    strapi.contentTypes[model.uid] = model;
-  });
-
-  // TODO: delete v3 code
-  _.forEach(strapi.plugins, plugin => {
-    _.forEach(plugin.contentTypes, (ct, ctUID) => {
-      strapi.contentTypes[ctUID] = ct.schema;
-    });
-
-    _.forEach(plugin.middlewares, (middleware, middlewareUID) => {
-      const middlewareName = toLower(middlewareUID.split('.')[1]);
-      strapi.middleware[middlewareName] = middleware;
-    });
-  });
-
-  // Preset config in alphabetical order.
-  strapi.config.middleware.settings = Object.keys(strapi.middleware).reduce((acc, current) => {
-    // Try to find the settings in the current environment, then in the main configurations.
-    const currentSettings = _.merge(
-      _.cloneDeep(_.get(strapi.middleware[current], ['defaults', current], {})),
-      strapi.config.get(['middleware', 'settings', current], {})
-    );
-
-    acc[current] = !_.isObject(currentSettings) ? {} : currentSettings;
-
-    // Ensure that enabled key exist by forcing to false.
-    _.defaults(acc[current], { enabled: false });
-
-    return acc;
-  }, {});
-
-  // default settings
-  strapi.config.port = strapi.config.get('server.port') || strapi.config.port;
-  strapi.config.host = strapi.config.get('server.host') || strapi.config.host;
-
-  const { serverUrl, adminUrl, adminPath } = getConfigUrls(strapi.config.get('server'));
-
-  strapi.config.server = strapi.config.server || {};
-  strapi.config.server.url = serverUrl;
-  strapi.config.admin.url = adminUrl;
-  strapi.config.admin.path = adminPath;
-
-  // check if we should serve admin panel
-  const shouldServeAdmin = strapi.config.get(
-    'server.admin.serveAdminPanel',
-    strapi.config.get('serveAdminPanel')
-  );
-
-  if (!shouldServeAdmin) {
-    strapi.config.serveAdminPanel = false;
-  }
-};

package/lib/core/loaders/load-apis.js

@@ -1,20 +0,0 @@
-'use strict';
-
-const { join } = require('path');
-const { existsSync } = require('fs-extra');
-const _ = require('lodash');
-const loadFiles = require('../../load/load-files');
-const loadConfig = require('../../load/load-config-files');
-
-module.exports = async ({ dir }) => {
-  const apiDir = join(dir, 'api');
-
-  if (!existsSync(apiDir)) {
-    throw new Error(`Missing api folder. Please create one in your app root directory`);
-  }
-
-  const apis = await loadFiles(apiDir, '*/!(config)/**/*.*(js|json)');
-  const apiConfigs = await loadConfig(apiDir, '*/config/**/*.*(js|json)');
-
-  return _.merge(apis, apiConfigs);
-};

package/lib/core/loaders/load-functions.js

@@ -1,21 +0,0 @@
-'use strict';
-
-const fse = require('fs-extra');
-
-const walk = require('./walk');
-
-const loadFunctions = dir => {
-  if (!fse.existsSync(dir)) return {};
-
-  return walk(dir, { loader: loadFunction });
-};
-
-const loadFunction = file => {
-  try {
-    return require(file);
-  } catch (error) {
-    throw `Could not load function ${file}: ${error.message}`;
-  }
-};
-
-module.exports = loadFunctions;

package/lib/core/loaders/load-middlewares.js

@@ -1,136 +0,0 @@
-'use strict';
-
-// Dependencies.
-const path = require('path');
-const fs = require('fs-extra');
-const _ = require('lodash');
-const glob = require('../../load/glob');
-const findPackagePath = require('../../load/package-path');
-
-/**
- * Load middlewares
- */
-module.exports = async function(strapi) {
-  const installedMiddlewares = strapi.config.get('installedMiddlewares');
-  const appPath = strapi.config.get('appPath');
-
-  let middlewares = {};
-
-  const loaders = createLoaders(strapi);
-
-  await loaders.loadMiddlewareDependencies(installedMiddlewares, middlewares);
-  // internal middlewares
-  await loaders.loadInternalMiddlewares(middlewares);
-  // local middleware
-  await loaders.loadLocalMiddlewares(appPath, middlewares);
-  // plugins middlewares
-  await loaders.loadPluginsMiddlewares(strapi.plugins, middlewares);
-  // local plugin middlewares
-  await loaders.loadLocalPluginsMiddlewares(appPath, middlewares);
-  // load admin middlewares
-  await loaders.loadAdminMiddlewares(middlewares);
-
-  return middlewares;
-};
-
-/**
- * Build loader functions
- * @param {*} strapi - strapi instance
- */
-const createLoaders = strapi => {
-  const loadMiddlewaresInDir = async (dir, middlewares) => {
-    const files = await glob('*/*(index|defaults).*(js|json)', {
-      cwd: dir,
-    });
-
-    files.forEach(f => {
-      const name = f.split('/')[0];
-      mountMiddleware(name, [path.resolve(dir, f)], middlewares);
-    });
-  };
-
-  const loadInternalMiddlewares = middlewares =>
-    loadMiddlewaresInDir(path.resolve(__dirname, '..', '..', 'middlewares'), middlewares);
-
-  const loadLocalMiddlewares = (appPath, middlewares) =>
-    loadMiddlewaresInDir(path.resolve(appPath, 'middlewares'), middlewares);
-
-  const loadPluginsMiddlewares = async (plugins, middlewares) => {
-    for (const pluginName in plugins) {
-      const pluginMiddlewares = plugins[pluginName].middlewares;
-      for (const middlewareName in pluginMiddlewares) {
-        middlewares[middlewareName] = {
-          loaded: false,
-          ...pluginMiddlewares[middlewareName],
-        };
-      }
-    }
-  };
-
-  const loadLocalPluginsMiddlewares = async (appPath, middlewares) => {
-    const pluginsDir = path.resolve(appPath, 'plugins');
-    if (!fs.existsSync(pluginsDir)) return;
-
-    const pluginsNames = await fs.readdir(pluginsDir);
-
-    for (let pluginFolder of pluginsNames) {
-      // ignore files
-      const stat = await fs.stat(path.resolve(pluginsDir, pluginFolder));
-      if (!stat.isDirectory()) continue;
-
-      const dir = path.resolve(pluginsDir, pluginFolder, 'middlewares');
-      await loadMiddlewaresInDir(dir, middlewares);
-    }
-  };
-
-  const loadAdminMiddlewares = async middlewares => {
-    const middlewaresDir = 'middlewares';
-    const dir = path.resolve(findPackagePath(`@strapi/admin`), middlewaresDir);
-    await loadMiddlewaresInDir(dir, middlewares);
-
-    // load ee admin middlewares if they exist
-    if (process.env.STRAPI_DISABLE_EE !== 'true' && strapi.EE) {
-      await loadMiddlewaresInDir(`${dir}/../ee/${middlewaresDir}`, middlewares);
-    }
-  };
-
-  const loadMiddlewareDependencies = async (packages, middlewares) => {
-    for (let packageName of packages) {
-      const baseDir = path.dirname(require.resolve(`@strapi/middleware-${packageName}`));
-      const files = await glob('*(index|defaults).*(js|json)', {
-        cwd: baseDir,
-        absolute: true,
-      });
-
-      mountMiddleware(packageName, files, middlewares);
-    }
-  };
-
-  const mountMiddleware = (name, files, middlewares) => {
-    files.forEach(file => {
-      middlewares[name] = middlewares[name] || { loaded: false };
-
-      if (_.endsWith(file, 'index.js') && !middlewares[name].load) {
-        return Object.defineProperty(middlewares[name], 'load', {
-          configurable: false,
-          enumerable: true,
-          get: () => require(file)(strapi),
-        });
-      }
-
-      if (_.endsWith(file, 'defaults.json')) {
-        middlewares[name].defaults = require(file);
-        return;
-      }
-    });
-  };
-
-  return {
-    loadInternalMiddlewares,
-    loadLocalMiddlewares,
-    loadPluginsMiddlewares,
-    loadLocalPluginsMiddlewares,
-    loadMiddlewareDependencies,
-    loadAdminMiddlewares,
-  };
-};

package/lib/core/loaders/load-modules.js

@@ -1,21 +0,0 @@
-'use strict';
-
-const loadApis = require('./load-apis');
-const loadMiddlewares = require('./load-middlewares');
-const loadComponents = require('./load-components');
-
-module.exports = async strapi => {
-  const [api, middlewares, components] = await Promise.all([
-    loadApis(strapi),
-    loadMiddlewares(strapi), // TODO: load in the middleware registry directly
-    loadComponents(strapi),
-  ]);
-
-  // TODO: move this into the appropriate loaders
-
-  return {
-    api,
-    middlewares,
-    components,
-  };
-};

package/lib/core/loaders/load-policies.js

@@ -1,36 +0,0 @@
-'use strict';
-
-const assert = require('assert');
-const path = require('path');
-const _ = require('lodash');
-const fse = require('fs-extra');
-
-module.exports = dir => {
-  if (!fse.existsSync(dir)) return {};
-
-  const root = {};
-  const paths = fse.readdirSync(dir, { withFileTypes: true }).filter(fd => fd.isFile());
-
-  for (let fd of paths) {
-    const { name } = fd;
-    const fullPath = dir + path.sep + name;
-
-    const ext = path.extname(name);
-    const key = path.basename(name, ext);
-    root[_.toLower(key)] = loadPolicy(fullPath);
-  }
-
-  return root;
-};
-
-const loadPolicy = file => {
-  try {
-    const policy = require(file);
-
-    assert(typeof policy === 'function', 'Policy must be a function.');
-
-    return policy;
-  } catch (error) {
-    throw `Could not load policy ${file}: ${error.message}`;
-  }
-};

package/lib/core/loaders/walk.js

@@ -1,27 +0,0 @@
-'use strict';
-
-const assert = require('assert');
-const path = require('path');
-const fse = require('fs-extra');
-
-module.exports = function walk(dir, { loader } = {}) {
-  assert(typeof loader === 'function', 'opts.loader must be a function');
-
-  const root = {};
-  const paths = fse.readdirSync(dir, { withFileTypes: true });
-
-  for (let fd of paths) {
-    const { name } = fd;
-    const fullPath = dir + path.sep + name;
-
-    if (fd.isDirectory()) {
-      root[name] = walk(fullPath, { loader });
-    } else {
-      const ext = path.extname(name);
-      const key = path.basename(name, ext);
-      root[key] = loader(fullPath);
-    }
-  }
-
-  return root;
-};

package/lib/core-api/index.js

@@ -1,39 +0,0 @@
-/**
- * Core API
- */
-'use strict';
-
-const _ = require('lodash');
-
-const createController = require('./controller');
-const { createService } = require('./service');
-
-/**
- * Returns a service and a controller built based on the content type passed
- *
- * @param {object} opts options
- * @param {object} opts.api api
- * @param {object} opts.model model
- * @param {object} opts.strapi strapi
- * @returns {object} controller & service
- */
-function createCoreApi({ api, model, strapi }) {
-  const { modelName } = model;
-
-  // find corresponding service and controller
-  const userService = _.get(api, ['services', modelName], {});
-  const userController = _.get(api, ['controllers', modelName], {});
-
-  const service = Object.assign(createService({ model, strapi }), userService);
-
-  const controller = Object.assign(createController({ service, model }), userController);
-
-  return {
-    service,
-    controller,
-  };
-}
-
-module.exports = {
-  createCoreApi,
-};

package/lib/load/check-reserved-filename.js

@@ -1,10 +0,0 @@
-'use strict';
-
-const _ = require('lodash');
-
-// files to load with filename key
-const prefixedPaths = ['functions', 'policies', 'locales', 'middleware', 'language', 'layout'];
-
-module.exports = function checkReservedFilenames(file) {
-  return _.some(prefixedPaths, e => file.indexOf(`config/${e}`) >= 0) ? true : false;
-};

package/lib/load/load-config-files.js

@@ -1,22 +0,0 @@
-'use strict';
-
-const loadFiles = require('./load-files');
-const requireFileAndParse = require('./require-file-parse');
-const checkReservedFilename = require('./check-reserved-filename');
-
-/**
- * @param {string} dir - directory from which to load configs
- * @param {string} pattern - glob pattern to search for config files
- */
-const loadConfigFiles = (dir, pattern = 'config/**/*.+(js|json)') =>
-  loadFiles(dir, pattern, {
-    requireFn: requireFileAndParse,
-    shouldUseFileNameAsKey: checkReservedFilename,
-    globArgs: {
-      // used to load .init.json at first startup
-      dot: true,
-      ignore: ['config/**/*.test.js'],
-    },
-  });
-
-module.exports = loadConfigFiles;

package/lib/load/require-file-parse.js

@@ -1,15 +0,0 @@
-'use strict';
-
-const path = require('path');
-const { templateConfiguration } = require('@strapi/utils');
-
-/**
- * Requires a file and eval expression if it is a json
- * @param {string} filePath - file path
- */
-module.exports = filePath => {
-  if (path.extname(filePath) === '.json') {
-    return templateConfiguration(require(filePath));
-  }
-  return require(filePath);
-};

package/lib/middlewares/boom/defaults.json

@@ -1,5 +0,0 @@
-{
-  "boom": {
-    "enabled": true
-  }
-}

package/lib/middlewares/boom/index.js

@@ -1,147 +0,0 @@
-'use strict';
-
-/**
- * Boom hook
- */
-
-// Public node modules.
-const _ = require('lodash');
-const Boom = require('boom');
-const delegate = require('delegates');
-
-const boomMethods = [
-  'badRequest',
-  'unauthorized',
-  'paymentRequired',
-  'forbidden',
-  'notFound',
-  'methodNotAllowed',
-  'notAcceptable',
-  'proxyAuthRequired',
-  'clientTimeout',
-  'conflict',
-  'resourceGone',
-  'lengthRequired',
-  'preconditionFailed',
-  'entityTooLarge',
-  'uriTooLong',
-  'unsupportedMediaType',
-  'rangeNotSatisfiable',
-  'expectationFailed',
-  'teapot',
-  'badData',
-  'locked',
-  'failedDependency',
-  'preconditionRequired',
-  'tooManyRequests',
-  'illegal',
-  'badImplementation',
-  'notImplemented',
-  'badGateway',
-  'serverUnavailable',
-  'gatewayTimeout',
-];
-
-const formatBoomPayload = boomError => {
-  if (!Boom.isBoom(boomError)) {
-    boomError = Boom.boomify(boomError, {
-      statusCode: boomError.status || 500,
-    });
-  }
-
-  const { output } = boomError;
-
-  if (output.statusCode < 500 && !_.isNil(boomError.data)) {
-    output.payload.data = boomError.data;
-  }
-
-  return { status: output.statusCode, body: output.payload };
-};
-
-module.exports = strapi => {
-  return {
-    /**
-     * Initialize the hook
-     */
-
-    initialize() {
-      this.delegator = delegate(strapi.app.context, 'response');
-      this.createResponses();
-
-      strapi.errors = Boom;
-      strapi.app.use(async (ctx, next) => {
-        try {
-          // App logic.
-          await next();
-        } catch (error) {
-          // emit error if configured
-          if (strapi.config.get('server.emitErrors', false)) {
-            strapi.app.emit('error', error, ctx);
-          }
-
-          // Log error.
-
-          const { status, body } = formatBoomPayload(error);
-
-          if (status >= 500) {
-            strapi.log.error(error);
-          }
-
-          ctx.body = body;
-          ctx.status = status;
-        }
-      });
-
-      strapi.app.use(async (ctx, next) => {
-        await next();
-        // Empty body is considered as `notFound` response.
-        if (_.isNil(ctx.body) && _.isNil(ctx.status)) {
-          ctx.notFound();
-        }
-      });
-    },
-
-    // Custom function to avoid ctx.body repeat
-    createResponses() {
-      boomMethods.forEach(method => {
-        strapi.app.response[method] = function(msg, ...rest) {
-          const boomError = Boom[method](msg, ...rest) || {};
-
-          const { status, body } = formatBoomPayload(boomError);
-
-          // keep retro-compatibility for old error formats
-          body.message = msg || body.data || body.message;
-
-          this.body = body;
-          this.status = status;
-        };
-
-        this.delegator.method(method);
-      });
-
-      strapi.app.response.send = function(data, status = 200) {
-        this.status = status;
-        this.body = data;
-      };
-
-      strapi.app.response.created = function(data) {
-        this.status = 201;
-        this.body = data;
-      };
-
-      strapi.app.response.deleted = function(data) {
-        if (_.isNil(data)) {
-          this.status = 204;
-        } else {
-          this.status = 200;
-          this.body = data;
-        }
-      };
-
-      this.delegator
-        .method('send')
-        .method('created')
-        .method('deleted');
-    },
-  };
-};