@strapi/strapi 4.0.0-beta.0

package/lib/core/app-configuration/index.js

@@ -0,0 +1,75 @@
+'use strict';
+
+const os = require('os');
+const path = require('path');
+const _ = require('lodash');
+const { omit } = require('lodash/fp');
+const dotenv = require('dotenv');
+
+dotenv.config({ path: process.env.ENV_PATH });
+
+process.env.NODE_ENV = process.env.NODE_ENV || 'development';
+
+const getPrefixedDeps = require('../../utils/get-prefixed-dependencies');
+const loadConfigDir = require('./config-loader');
+const loadFunction = require('./load-functions');
+
+const { version: strapiVersion } = require(path.join(__dirname, '../../../package.json'));
+
+const CONFIG_PATHS = {
+  config: 'config',
+  static: 'public',
+  views: 'views',
+};
+
+const defaultConfig = {
+  server: {
+    host: process.env.HOST || os.hostname() || 'localhost',
+    port: process.env.PORT || 1337,
+    proxy: false,
+    cron: { enabled: false },
+    admin: { autoOpen: false },
+  },
+  admin: {},
+  middleware: {
+    timeout: 1000,
+    load: {
+      before: ['responseTime', 'logger', 'cors', 'responses', 'gzip'],
+      order: [],
+      after: ['parser', 'router'],
+    },
+    settings: {},
+  },
+};
+
+module.exports = (dir, initialConfig = {}) => {
+  const { autoReload = false, serveAdminPanel = true } = initialConfig;
+
+  const pkgJSON = require(path.resolve(dir, 'package.json'));
+
+  const configDir = path.resolve(dir || process.cwd(), 'config');
+
+  const rootConfig = {
+    launchedAt: Date.now(),
+    appPath: dir,
+    paths: CONFIG_PATHS,
+    serveAdminPanel,
+    autoReload,
+    environment: process.env.NODE_ENV,
+    uuid: _.get(pkgJSON, 'strapi.uuid'),
+    packageJsonStrapi: _.omit(_.get(pkgJSON, 'strapi', {}), 'uuid'),
+    info: {
+      ...pkgJSON,
+      strapi: strapiVersion,
+    },
+    functions: loadFunction(path.join(configDir, 'functions')),
+    installedMiddlewares: getPrefixedDeps('@strapi/middleware', pkgJSON),
+  };
+
+  const baseConfig = omit('plugins', loadConfigDir(configDir)); // plugin config will be loaded later
+
+  const envDir = path.resolve(configDir, 'env', process.env.NODE_ENV);
+  const envConfig = loadConfigDir(envDir);
+
+  return _.merge(rootConfig, defaultConfig, baseConfig, envConfig);
+};

package/lib/core/app-configuration/load-config-file.js

@@ -0,0 +1,43 @@
+'use strict';
+
+const path = require('path');
+const fs = require('fs');
+const { templateConfiguration, env } = require('@strapi/utils');
+
+const loadJsFile = file => {
+  try {
+    const jsModule = require(file);
+
+    // call if function
+    if (typeof jsModule === 'function') {
+      return jsModule({ env });
+    }
+
+    return jsModule;
+  } catch (error) {
+    throw new Error(`Could not load js config file ${file}: ${error.message}`);
+  }
+};
+
+const loadJSONFile = file => {
+  try {
+    return templateConfiguration(JSON.parse(fs.readFileSync(file)));
+  } catch (error) {
+    throw new Error(`Could not load json config file ${file}: ${error.message}`);
+  }
+};
+
+const loadFile = file => {
+  const ext = path.extname(file);
+
+  switch (ext) {
+    case '.js':
+      return loadJsFile(file);
+    case '.json':
+      return loadJSONFile(file);
+    default:
+      return {};
+  }
+};
+
+module.exports = loadFile;

package/lib/core/app-configuration/load-functions.js

@@ -0,0 +1,28 @@
+'use strict';
+
+const { join, extname, basename } = require('path');
+const fse = require('fs-extra');
+
+module.exports = function loadFunctions(dir) {
+  const functions = {};
+
+  if (!fse.pathExistsSync(dir)) {
+    return functions;
+  }
+
+  const paths = fse.readdirSync(dir, { withFileTypes: true });
+
+  for (const fd of paths) {
+    const { name } = fd;
+    const fullPath = join(dir, name);
+
+    if (fd.isDirectory()) {
+      functions[name] = loadFunctions(fullPath);
+    } else if (fd.isFile() && extname(name) === '.js') {
+      const key = basename(name, '.js');
+      functions[key] = require(fullPath);
+    }
+  }
+
+  return functions;
+};

package/lib/core/bootstrap.js

@@ -0,0 +1,60 @@
+'use strict';
+
+const _ = require('lodash');
+const { getConfigUrls } = require('@strapi/utils');
+
+module.exports = function({ strapi }) {
+  // TODO: delete v3 code
+  _.forEach(strapi.api, api => {
+    _.forEach(api.middlewares, (middleware, middlewareName) => {
+      strapi.middleware[middlewareName] = middleware;
+    });
+  });
+
+  _.forEach(strapi.admin.middlewares, (middleware, middlewareName) => {
+    strapi.middleware[middlewareName] = middleware;
+  });
+
+  _.forEach(strapi.plugins, plugin => {
+    _.forEach(plugin.middlewares, (middleware, middlewareName) => {
+      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/domain/component/index.js

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

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

@@ -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,106 @@
+'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);
+    },
+    routes: 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,36 @@
+'use strict';
+
+const _ = require('lodash');
+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 {
+        const shape = _.mapValues(value, () => yup.object({ routes: yup.array().required() }));
+
+        return yup.object(shape);
+      }
+    }),
+    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('server.admin');
+  strapi.container.get('config').set('server.admin', _.merge(strapi.admin.config, userAdminConfig));
+};