@strapi/strapi 4.14.0-beta.0 → 4.14.1

package/lib/core/bootstrap.js

@@ -1,33 +0,0 @@
-'use strict';
-
-const { getConfigUrls } = require('@strapi/utils');
-const fse = require('fs-extra');
-
-module.exports = async function ({ strapi }) {
-  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);
-
-  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(
-    'admin.serveAdminPanel',
-    strapi.config.get('serveAdminPanel')
-  );
-
-  if (!shouldServeAdmin) {
-    strapi.config.serveAdminPanel = false;
-  }
-
-  // ensure public repository exists
-  if (!(await fse.pathExists(strapi.dirs.static.public))) {
-    throw new Error(
-      `The public folder (${strapi.dirs.static.public}) doesn't exist or is not accessible. Please make sure it exists.`
-    );
-  }
-};

package/lib/core/domain/component/index.js

@@ -1,24 +0,0 @@
-'use strict';
-
-const { cloneDeep, camelCase } = require('lodash/fp');
-const { validateComponentDefinition } = require('./validator');
-
-const createComponent = (definition = {}) => {
-  validateComponentDefinition(definition);
-
-  const createdComponent = cloneDeep(definition);
-  const category = camelCase(definition.info.category);
-
-  const uid = `${category}.${definition.info.singularModelName}`;
-
-  Object.assign(createdComponent, {
-    uid,
-    category,
-  });
-
-  return createdComponent;
-};
-
-module.exports = {
-  createComponent,
-};

package/lib/core/domain/component/validator.js

@@ -1,23 +0,0 @@
-'use strict';
-
-const { yup } = require('@strapi/utils');
-
-const componentSchemaValidator = () =>
-  yup.object().shape({
-    info: yup
-      .object()
-      .shape({
-        singularName: yup.string().isCamelCase().required(),
-        pluralName: yup.string().isCamelCase().required(),
-        displayName: yup.string().required(),
-      })
-      .required(),
-  });
-
-const validateComponentDefinition = (data) => {
-  return componentSchemaValidator.validateSync(data, { strict: true, abortEarly: false });
-};
-
-module.exports = {
-  validateComponentDefinition,
-};

package/lib/core/domain/content-type/index.js

@@ -1,134 +0,0 @@
-'use strict';
-
-const { cloneDeep } = require('lodash/fp');
-const _ = require('lodash');
-const { hasDraftAndPublish } = require('@strapi/utils').contentTypes;
-const {
-  CREATED_AT_ATTRIBUTE,
-  UPDATED_AT_ATTRIBUTE,
-  PUBLISHED_AT_ATTRIBUTE,
-  CREATED_BY_ATTRIBUTE,
-  UPDATED_BY_ATTRIBUTE,
-} = require('@strapi/utils').contentTypes.constants;
-const { validateContentTypeDefinition } = require('./validator');
-
-const createContentType = (uid, definition) => {
-  try {
-    validateContentTypeDefinition(definition);
-  } catch (e) {
-    throw new Error(`Content Type Definition is invalid for ${uid}'.\n${e.errors}`);
-  }
-
-  const { schema, actions, lifecycles } = cloneDeep(definition);
-
-  // general info
-  Object.assign(schema, {
-    kind: schema.kind || 'collectionType',
-    __schema__: pickSchema(definition.schema),
-    modelType: 'contentType',
-    modelName: definition.schema.info.singularName,
-    connection: 'default',
-  });
-
-  if (uid.startsWith('api::')) {
-    Object.assign(schema, {
-      uid,
-      apiName: uid.split('::')[1].split('.')[0],
-      collectionName: schema.collectionName || schema.info.singularName,
-      globalId: getGlobalId(schema, schema.info.singularName),
-    });
-  } else if (uid.startsWith('plugin::')) {
-    const pluginName = uid.split('::')[1].split('.')[0];
-    Object.assign(schema, {
-      uid,
-      plugin: pluginName, // TODO: to be set in load-plugins.js
-      collectionName:
-        schema.collectionName || `${pluginName}_${schema.info.singularName}`.toLowerCase(),
-      globalId: getGlobalId(schema, schema.info.singularName, pluginName),
-    });
-  } else if (uid.startsWith('admin::')) {
-    Object.assign(schema, {
-      uid,
-      plugin: 'admin',
-      globalId: getGlobalId(schema, schema.info.singularName, 'admin'),
-    });
-  } else {
-    throw new Error(
-      `Incorrect Content Type UID "${uid}". The UID should start with api::, plugin:: or admin::.`
-    );
-  }
-
-  // attributes
-  Object.assign(schema.attributes, {
-    [CREATED_AT_ATTRIBUTE]: {
-      type: 'datetime',
-    },
-    // TODO: handle on edit set to new date
-    [UPDATED_AT_ATTRIBUTE]: {
-      type: 'datetime',
-    },
-  });
-
-  if (hasDraftAndPublish(schema)) {
-    schema.attributes[PUBLISHED_AT_ATTRIBUTE] = {
-      type: 'datetime',
-      configurable: false,
-      writable: true,
-      visible: false,
-    };
-  }
-
-  const isPrivate = !_.get(schema, 'options.populateCreatorFields', false);
-
-  schema.attributes[CREATED_BY_ATTRIBUTE] = {
-    type: 'relation',
-    relation: 'oneToOne',
-    target: 'admin::user',
-    configurable: false,
-    writable: false,
-    visible: false,
-    useJoinTable: false,
-    private: isPrivate,
-  };
-
-  schema.attributes[UPDATED_BY_ATTRIBUTE] = {
-    type: 'relation',
-    relation: 'oneToOne',
-    target: 'admin::user',
-    configurable: false,
-    writable: false,
-    visible: false,
-    useJoinTable: false,
-    private: isPrivate,
-  };
-
-  Object.assign(schema, { actions, lifecycles });
-
-  return schema;
-};
-
-const getGlobalId = (model, modelName, prefix) => {
-  const globalId = prefix ? `${prefix}-${modelName}` : modelName;
-
-  return model.globalId || _.upperFirst(_.camelCase(globalId));
-};
-
-const pickSchema = (model) => {
-  const schema = _.cloneDeep(
-    _.pick(model, [
-      'connection',
-      'collectionName',
-      'info',
-      'options',
-      'pluginOptions',
-      'attributes',
-    ])
-  );
-
-  schema.kind = model.kind || 'collectionType';
-  return schema;
-};
-
-module.exports = {
-  createContentType,
-};

package/lib/core/domain/content-type/validator.js

@@ -1,105 +0,0 @@
-'use strict';
-
-const _ = require('lodash');
-const { yup, toRegressedEnumValue } = require('@strapi/utils');
-
-const LIFECYCLES = [
-  'beforeCreate',
-  'afterCreate',
-  'beforeFindOne',
-  'afterFindOne',
-  'beforeFindMany',
-  'afterFindMany',
-  'beforeCount',
-  'afterCount',
-  'beforeCreateMany',
-  'afterCreateMany',
-  'beforeUpdate',
-  'afterUpdate',
-  'beforeUpdateMany',
-  'afterUpdateMany',
-  'beforeDelete',
-  'afterDelete',
-  'beforeDeleteMany',
-  'afterDeleteMany',
-];
-
-/**
- * For enumerations the least common denomiator is GraphQL, where
- * values needs to match the secure name regex:
- * GraphQL Spec https://spec.graphql.org/June2018/#sec-Names
- *
- * Therefore we need to make sure our users only use values, which
- * can be returned by GraphQL, by checking the regressed values
- * agains the GraphQL regex.
- *
- * TODO V5: check if we can avoid this coupling by moving this logic
- * into the GraphQL plugin.
- */
-const GRAPHQL_ENUM_REGEX = /^[_A-Za-z][_0-9A-Za-z]*$/;
-
-const lifecyclesShape = _.mapValues(_.keyBy(LIFECYCLES), () => yup.mixed().nullable().isFunction());
-
-const contentTypeSchemaValidator = yup.object().shape({
-  schema: yup.object().shape({
-    info: yup
-      .object()
-      .shape({
-        displayName: yup.string().required(),
-        singularName: yup.string().isKebabCase().required(),
-        pluralName: yup.string().isKebabCase().required(),
-      })
-      .required(),
-    attributes: yup.object().test({
-      name: 'valuesCollide',
-      message: 'Some values collide when normalized',
-      test(attributes) {
-        for (const attrName of Object.keys(attributes)) {
-          const attr = attributes[attrName];
-          if (attr.type === 'enumeration') {
-            const regressedValues = attr.enum.map(toRegressedEnumValue);
-
-            // should match the GraphQL regex
-            if (!regressedValues.every((value) => GRAPHQL_ENUM_REGEX.test(value))) {
-              const message = `Invalid enumeration value. Values should have at least one alphabetical character preceding the first occurence of a number. Update your enumeration '${attrName}'.`;
-
-              return this.createError({ message });
-            }
-
-            // should not contain empty values
-            if (regressedValues.some((value) => value === '')) {
-              return this.createError({
-                message: `At least one value of the enumeration '${attrName}' appears to be empty. Only alphanumerical characters are taken into account.`,
-              });
-            }
-
-            // should not collide
-            const duplicates = _.uniq(
-              regressedValues.filter((value, index, values) => values.indexOf(value) !== index)
-            );
-
-            if (duplicates.length) {
-              const message = `Some enumeration values of the field '${attrName}' collide when normalized: ${duplicates.join(
-                ', '
-              )}. Please modify your enumeration.`;
-
-              return this.createError({ message });
-            }
-          }
-        }
-
-        return true;
-      },
-    }),
-  }),
-  actions: yup.object().onlyContainsFunctions(),
-  lifecycles: yup.object().shape(lifecyclesShape).noUnknown(),
-});
-
-const validateContentTypeDefinition = (data) => {
-  return contentTypeSchemaValidator.validateSync(data, { strict: true, abortEarly: false });
-};
-
-module.exports = {
-  validateContentTypeDefinition,
-};

package/lib/core/domain/module/index.js

@@ -1,108 +0,0 @@
-'use strict';
-
-const _ = require('lodash');
-const { removeNamespace } = require('../../utils');
-const { validateModule } = require('./validation');
-
-const uidToPath = (uid) => uid.replace('::', '.');
-
-// Removes the namespace from a map with keys prefixed with a namespace
-const removeNamespacedKeys = (map, namespace) => {
-  return _.mapKeys(map, (value, key) => removeNamespace(key, namespace));
-};
-
-const defaultModule = {
-  config: {},
-  routes: [],
-  controllers: {},
-  services: {},
-  contentTypes: {},
-  policies: {},
-  middlewares: {},
-};
-
-const createModule = (namespace, rawModule, strapi) => {
-  _.defaults(rawModule, defaultModule);
-
-  try {
-    validateModule(rawModule);
-  } catch (e) {
-    throw new Error(`strapi-server.js is invalid for '${namespace}'.\n${e.errors.join('\n')}`);
-  }
-
-  const called = {};
-  return {
-    async bootstrap() {
-      if (called.bootstrap) {
-        throw new Error(`Bootstrap for ${namespace} has already been called`);
-      }
-      called.bootstrap = true;
-      await (rawModule.bootstrap && rawModule.bootstrap({ strapi }));
-    },
-    async register() {
-      if (called.register) {
-        throw new Error(`Register for ${namespace} has already been called`);
-      }
-      called.register = true;
-      await (rawModule.register && rawModule.register({ strapi }));
-    },
-    async destroy() {
-      if (called.destroy) {
-        throw new Error(`Destroy for ${namespace} has already been called`);
-      }
-      called.destroy = true;
-      await (rawModule.destroy && rawModule.destroy({ strapi }));
-    },
-    load() {
-      strapi.container.get('content-types').add(namespace, rawModule.contentTypes);
-      strapi.container.get('services').add(namespace, rawModule.services);
-      strapi.container.get('policies').add(namespace, rawModule.policies);
-      strapi.container.get('middlewares').add(namespace, rawModule.middlewares);
-      strapi.container.get('controllers').add(namespace, rawModule.controllers);
-      strapi.container.get('config').set(uidToPath(namespace), rawModule.config);
-    },
-    get routes() {
-      return rawModule.routes;
-    },
-    config(path, defaultValue) {
-      return strapi.container.get('config').get(`${uidToPath(namespace)}.${path}`, defaultValue);
-    },
-    contentType(ctName) {
-      return strapi.container.get('content-types').get(`${namespace}.${ctName}`);
-    },
-    get contentTypes() {
-      const contentTypes = strapi.container.get('content-types').getAll(namespace);
-      return removeNamespacedKeys(contentTypes, namespace);
-    },
-    service(serviceName) {
-      return strapi.container.get('services').get(`${namespace}.${serviceName}`);
-    },
-    get services() {
-      const services = strapi.container.get('services').getAll(namespace);
-      return removeNamespacedKeys(services, namespace);
-    },
-    policy(policyName) {
-      return strapi.container.get('policies').get(`${namespace}.${policyName}`);
-    },
-    get policies() {
-      const policies = strapi.container.get('policies').getAll(namespace);
-      return removeNamespacedKeys(policies, namespace);
-    },
-    middleware(middlewareName) {
-      return strapi.container.get('middlewares').get(`${namespace}.${middlewareName}`);
-    },
-    get middlewares() {
-      const middlewares = strapi.container.get('middlewares').getAll(namespace);
-      return removeNamespacedKeys(middlewares, namespace);
-    },
-    controller(controllerName) {
-      return strapi.container.get('controllers').get(`${namespace}.${controllerName}`);
-    },
-    get controllers() {
-      const controllers = strapi.container.get('controllers').getAll(namespace);
-      return removeNamespacedKeys(controllers, namespace);
-    },
-  };
-};
-
-module.exports = { createModule };

package/lib/core/domain/module/validation.js

@@ -1,32 +0,0 @@
-'use strict';
-
-const { yup } = require('@strapi/utils');
-
-const strapiServerSchema = yup
-  .object()
-  .shape({
-    bootstrap: yup.mixed().isFunction(),
-    destroy: yup.mixed().isFunction(),
-    register: yup.mixed().isFunction(),
-    config: yup.object(),
-    routes: yup.lazy((value) => {
-      if (Array.isArray(value)) {
-        return yup.array();
-      }
-      return yup.object();
-    }),
-    controllers: yup.object(),
-    services: yup.object(),
-    policies: yup.object(),
-    middlewares: yup.object(),
-    contentTypes: yup.object(),
-  })
-  .noUnknown();
-
-const validateModule = (data) => {
-  return strapiServerSchema.validateSync(data, { strict: true, abortEarly: false });
-};
-
-module.exports = {
-  validateModule,
-};

package/lib/core/loaders/admin.js

@@ -1,16 +0,0 @@
-'use strict';
-
-const _ = require('lodash');
-
-module.exports = (strapi) => {
-  strapi.admin = require('@strapi/admin/strapi-server');
-
-  strapi.container.get('services').add(`admin::`, strapi.admin.services);
-  strapi.container.get('controllers').add(`admin::`, strapi.admin.controllers);
-  strapi.container.get('content-types').add(`admin::`, strapi.admin.contentTypes);
-  strapi.container.get('policies').add(`admin::`, strapi.admin.policies);
-  strapi.container.get('middlewares').add(`admin::`, strapi.admin.middlewares);
-
-  const userAdminConfig = strapi.config.get('admin');
-  strapi.container.get('config').set('admin', _.merge(strapi.admin.config, userAdminConfig));
-};

package/lib/core/loaders/apis.js

@@ -1,161 +0,0 @@
-'use strict';
-
-const { join, extname, basename } = require('path');
-const { existsSync } = require('fs-extra');
-const _ = require('lodash');
-const fse = require('fs-extra');
-const { isKebabCase, importDefault } = require('@strapi/utils');
-const { isEmpty } = require('lodash/fp');
-
-const DEFAULT_CONTENT_TYPE = {
-  schema: {},
-  actions: {},
-  lifecycles: {},
-};
-
-// to handle names with numbers in it we first check if it is already in kebabCase
-const normalizeName = (name) => (isKebabCase(name) ? name : _.kebabCase(name));
-
-const isDirectory = (fd) => fd.isDirectory();
-const isDotFile = (fd) => fd.name.startsWith('.');
-
-module.exports = async (strapi) => {
-  if (!existsSync(strapi.dirs.dist.api)) {
-    return;
-  }
-
-  const apisFDs = await (await fse.readdir(strapi.dirs.dist.api, { withFileTypes: true }))
-    .filter(isDirectory)
-    .filter(_.negate(isDotFile));
-
-  const apis = {};
-
-  // only load folders
-  for (const apiFD of apisFDs) {
-    const apiName = normalizeName(apiFD.name);
-    const api = await loadAPI(join(strapi.dirs.dist.api, apiFD.name));
-
-    apis[apiName] = api;
-  }
-
-  validateContentTypesUnicity(apis);
-
-  for (const apiName of Object.keys(apis)) {
-    strapi.container.get('apis').add(apiName, apis[apiName]);
-  }
-};
-
-const validateContentTypesUnicity = (apis) => {
-  const allApisSchemas = Object.values(apis).flatMap((api) => Object.values(api.contentTypes));
-
-  const names = [];
-  allApisSchemas.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);
-    }
-  });
-};
-
-const loadAPI = async (dir) => {
-  const [index, config, routes, controllers, services, policies, middlewares, contentTypes] =
-    await Promise.all([
-      loadIndex(dir),
-      loadDir(join(dir, 'config')),
-      loadDir(join(dir, 'routes')),
-      loadDir(join(dir, 'controllers')),
-      loadDir(join(dir, 'services')),
-      loadDir(join(dir, 'policies')),
-      loadDir(join(dir, 'middlewares')),
-      loadContentTypes(join(dir, 'content-types')),
-    ]);
-
-  return {
-    ...(index || {}),
-    config: config || {},
-    routes: routes || [],
-    controllers: controllers || {},
-    services: services || {},
-    policies: policies || {},
-    middlewares: middlewares || {},
-    contentTypes: contentTypes || {},
-  };
-};
-
-const loadIndex = async (dir) => {
-  if (await fse.pathExists(join(dir, 'index.js'))) {
-    return loadFile(join(dir, 'index.js'));
-  }
-};
-
-const loadContentTypes = async (dir) => {
-  if (!(await fse.pathExists(dir))) {
-    return;
-  }
-
-  const fds = await fse.readdir(dir, { withFileTypes: true });
-  const contentTypes = {};
-
-  // only load folders
-  for (const fd of fds) {
-    if (fd.isFile()) {
-      continue;
-    }
-
-    const contentTypeName = normalizeName(fd.name);
-    const contentType = await loadDir(join(dir, fd.name));
-
-    if (isEmpty(contentType) || isEmpty(contentType.schema)) {
-      throw new Error(`Could not load content type found at ${dir}`);
-    }
-
-    contentTypes[normalizeName(contentTypeName)] = _.defaults(contentType, DEFAULT_CONTENT_TYPE);
-  }
-
-  return contentTypes;
-};
-
-const loadDir = async (dir) => {
-  if (!(await fse.pathExists(dir))) {
-    return;
-  }
-
-  const fds = await fse.readdir(dir, { withFileTypes: true });
-
-  const root = {};
-  for (const fd of fds) {
-    if (!fd.isFile() || extname(fd.name) === '.map') {
-      continue;
-    }
-
-    const key = basename(fd.name, extname(fd.name));
-
-    root[normalizeName(key)] = await loadFile(join(dir, fd.name));
-  }
-
-  return root;
-};
-
-const loadFile = (file) => {
-  const ext = extname(file);
-
-  switch (ext) {
-    case '.js':
-      return importDefault(file);
-    case '.json':
-      return fse.readJSON(file);
-    default:
-      return {};
-  }
-};

package/lib/core/loaders/components.js

@@ -1,42 +0,0 @@
-'use strict';
-
-const { join } = require('path');
-const _ = require('lodash');
-const { pathExists } = require('fs-extra');
-const loadFiles = require('../../load/load-files');
-
-module.exports = async (strapi) => {
-  if (!(await pathExists(strapi.dirs.dist.components))) {
-    return {};
-  }
-
-  const map = await loadFiles(strapi.dirs.dist.components, '*/*.*(js|json)');
-
-  return Object.keys(map).reduce((acc, category) => {
-    Object.keys(map[category]).forEach((key) => {
-      const schema = map[category][key];
-
-      if (!schema.collectionName) {
-        // NOTE: We're using the filepath from the app directory instead of the dist for information purpose
-        const filePath = join(strapi.dirs.app.components, category, schema.__filename__);
-
-        return strapi.stopWithError(
-          `Component ${key} is missing a "collectionName" property.\nVerify file ${filePath}.`
-        );
-      }
-
-      const uid = `${category}.${key}`;
-
-      acc[uid] = Object.assign(schema, {
-        __schema__: _.cloneDeep(schema),
-        uid,
-        category,
-        modelType: 'component',
-        modelName: key,
-        globalId: schema.globalId || _.upperFirst(_.camelCase(`component_${uid}`)),
-      });
-    });
-
-    return acc;
-  }, {});
-};

package/lib/core/loaders/index.js

@@ -1,13 +0,0 @@
-'use strict';
-
-module.exports = {
-  loadSrcIndex: require('./src-index'),
-  loadAPIs: require('./apis'),
-  loadMiddlewares: require('./middlewares'),
-  loadComponents: require('./components'),
-  loadPolicies: require('./policies'),
-  loadPlugins: require('./plugins'),
-  loadAdmin: require('./admin'),
-  loadSanitizers: require('./sanitizers'),
-  loadValidators: require('./validators'),
-};