@strapi/strapi 4.0.0-next.6 → 4.0.0

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

@@ -0,0 +1,140 @@
+'use strict';
+
+const { cloneDeep } = require('lodash/fp');
+const _ = require('lodash');
+const { hasDraftAndPublish, getPrivateAttributes } = 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 strapi::.`
+    );
+  }
+
+  Object.defineProperty(schema, 'privateAttributes', {
+    get() {
+      return getPrivateAttributes(schema);
+    },
+  });
+
+  // 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) => {
+  let 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

@@ -0,0 +1,64 @@
+'use strict';
+
+const { keyBy, mapValues } = require('lodash');
+const { yup } = require('@strapi/utils');
+
+const LIFECYCLES = [
+  'beforeCreate',
+  'afterCreate',
+  'beforeFindOne',
+  'afterFindOne',
+  'beforeFindMany',
+  'afterFindMany',
+  'beforeCount',
+  'afterCount',
+  'beforeCreateMany',
+  'afterCreateMany',
+  'beforeUpdate',
+  'afterUpdate',
+  'beforeUpdateMany',
+  'afterUpdateMany',
+  'beforeDelete',
+  'afterDelete',
+  'beforeDeleteMany',
+  'afterDeleteMany',
+];
+
+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(),
+  }),
+  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

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

@@ -0,0 +1,33 @@
+'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();
+      } else {
+        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

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

@@ -0,0 +1,159 @@
+'use strict';
+
+const { join, extname, basename } = require('path');
+const { existsSync } = require('fs-extra');
+const _ = require('lodash');
+const fse = require('fs-extra');
+const { isKebabCase } = require('@strapi/utils');
+
+// 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 DEFAULT_CONTENT_TYPE = {
+  schema: {},
+  actions: {},
+  lifecycles: {},
+};
+
+module.exports = async strapi => {
+  if (!existsSync(strapi.dirs.api)) {
+    throw new Error('Missing api folder. Please create one at `./src/api`');
+  }
+
+  const apisFDs = await fse.readdir(strapi.dirs.api, { withFileTypes: true });
+  const apis = {};
+
+  // only load folders
+  for (const apiFD of apisFDs) {
+    if (apiFD.isDirectory()) {
+      const apiName = normalizeName(apiFD.name);
+      const api = await loadAPI(join(strapi.dirs.api, apiFD.name));
+
+      apis[apiName] = api;
+    }
+  }
+
+  validateContentTypesUnicity(apis);
+
+  for (const apiName in 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));
+
+    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()) {
+      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 require(file);
+    case '.json':
+      return fse.readJSON(file);
+    default:
+      return {};
+  }
+};

package/lib/core/{load-components.js → loaders/components.js}

@@ -2,23 +2,21 @@
 
 const { join } = require('path');
 const _ = require('lodash');
-const { exists } = require('fs-extra');
-const loadFiles = require('../load/load-files');
+const { pathExists } = require('fs-extra');
+const loadFiles = require('../../load/load-files');
 
 module.exports = async strapi => {
-  const componentsDir = join(strapi.dir, 'components');
-
-  if (!(await exists(componentsDir))) {
+  if (!(await pathExists(strapi.dirs.components))) {
     return {};
   }
 
-  const map = await loadFiles(componentsDir, '*/*.*(js|json)');
+  const map = await loadFiles(strapi.dirs.components, '*/*.*(js|json)');
 
   return Object.keys(map).reduce((acc, category) => {
     Object.keys(map[category]).forEach(key => {
       const schema = map[category][key];
 
-      const filePath = join(componentsDir, category, schema.__filename__);
+      const filePath = join(strapi.dirs.components, category, schema.__filename__);
 
       if (!schema.collectionName) {
         return strapi.stopWithError(

package/lib/core/loaders/index.js

@@ -0,0 +1,11 @@
+'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'),
+};

package/lib/core/loaders/middlewares.js

@@ -0,0 +1,36 @@
+'use strict';
+
+const { join, extname, basename } = require('path');
+const fse = require('fs-extra');
+
+// TODO:: allow folders with index.js inside for bigger policies
+module.exports = async function loadMiddlewares(strapi) {
+  const localMiddlewares = await loadLocalMiddlewares(strapi);
+  const internalMiddlewares = require('../../middlewares');
+
+  strapi.container.get('middlewares').add(`global::`, localMiddlewares);
+  strapi.container.get('middlewares').add(`strapi::`, internalMiddlewares);
+};
+
+const loadLocalMiddlewares = async strapi => {
+  const dir = strapi.dirs.middlewares;
+
+  if (!(await fse.pathExists(dir))) {
+    return {};
+  }
+
+  const middlewares = {};
+  const paths = await fse.readdir(dir, { withFileTypes: true });
+
+  for (const fd of paths) {
+    const { name } = fd;
+    const fullPath = join(dir, name);
+
+    if (fd.isFile() && extname(name) === '.js') {
+      const key = basename(name, '.js');
+      middlewares[key] = require(fullPath);
+    }
+  }
+
+  return middlewares;
+};