@strapi/strapi 4.0.0-next.7 → 4.0.1

package/lib/commands/generate-template.js

@@ -6,7 +6,7 @@ const chalk = require('chalk');
 const inquirer = require('inquirer');
 
 // All directories that a template could need
-const TEMPLATE_CONTENT = ['api', 'components', 'config/functions/bootstrap.js', 'data'];
+const TEMPLATE_CONTENT = ['src', 'data'];
 
 /**
  *
@@ -54,10 +54,9 @@ async function writeTemplateJson(rootPath) {
  * @returns boolean
  */
 async function templateConfigExists(rootPath) {
-  const jsonConfig = await fse.pathExists(join(rootPath, 'template.json'));
-  const functionConfig = await fse.pathExists(join(rootPath, 'template.js'));
-
-  return jsonConfig || functionConfig;
+  const configExists = await fse.pathExists(join(rootPath, 'template.json'));
+  console.log(`checking: ${join(rootPath, 'template.json')}. result ${configExists}`);
+  return configExists;
 }
 
 module.exports = async function generateTemplate(directory) {

package/lib/commands/hooks/list.js

@@ -0,0 +1,22 @@
+'use strict';
+
+const CLITable = require('cli-table3');
+const chalk = require('chalk');
+
+const strapi = require('../../index');
+
+module.exports = async function() {
+  const app = await strapi().register();
+
+  const list = app.container.get('hooks').keys();
+
+  const infoTable = new CLITable({
+    head: [chalk.blue('Name')],
+  });
+
+  list.forEach(name => infoTable.push([name]));
+
+  console.log(infoTable.toString());
+
+  await app.destroy();
+};

package/lib/commands/middlewares/list.js

@@ -0,0 +1,22 @@
+'use strict';
+
+const CLITable = require('cli-table3');
+const chalk = require('chalk');
+
+const strapi = require('../../index');
+
+module.exports = async function() {
+  const app = await strapi().register();
+
+  const list = app.container.get('middlewares').keys();
+
+  const infoTable = new CLITable({
+    head: [chalk.blue('Name')],
+  });
+
+  list.forEach(name => infoTable.push([name]));
+
+  console.log(infoTable.toString());
+
+  await app.destroy();
+};

package/lib/commands/new.js

@@ -1,5 +1,7 @@
 'use strict';
 
+const { generateNewApp } = require('@strapi/generate-new');
+
 /**
  * `$ strapi new`
  *
@@ -7,5 +9,5 @@
  */
 
 module.exports = function(...args) {
-  return require('@strapi/generate-new')(...args);
+  return generateNewApp(...args);
 };

package/lib/commands/policies/list.js

@@ -0,0 +1,22 @@
+'use strict';
+
+const CLITable = require('cli-table3');
+const chalk = require('chalk');
+
+const strapi = require('../../index');
+
+module.exports = async function() {
+  const app = await strapi().register();
+
+  const list = app.container.get('policies').keys();
+
+  const infoTable = new CLITable({
+    head: [chalk.blue('Name')],
+  });
+
+  list.forEach(name => infoTable.push([name]));
+
+  console.log(infoTable.toString());
+
+  await app.destroy();
+};

package/lib/commands/routes/list.js

@@ -0,0 +1,28 @@
+'use strict';
+
+const CLITable = require('cli-table3');
+const chalk = require('chalk');
+const { toUpper } = require('lodash/fp');
+
+const strapi = require('../../index');
+
+module.exports = async function() {
+  const app = await strapi().load();
+
+  const list = app.server.listRoutes();
+
+  const infoTable = new CLITable({
+    head: [chalk.blue('Method'), chalk.blue('Path')],
+    colWidths: [20],
+  });
+
+  list
+    .filter(route => route.methods.length)
+    .forEach(route => {
+      infoTable.push([route.methods.map(toUpper).join('|'), route.path]);
+    });
+
+  console.log(infoTable.toString());
+
+  await app.destroy();
+};

package/lib/commands/services/list.js

@@ -0,0 +1,22 @@
+'use strict';
+
+const CLITable = require('cli-table3');
+const chalk = require('chalk');
+
+const strapi = require('../../index');
+
+module.exports = async function() {
+  const app = await strapi().register();
+
+  const list = app.container.get('services').keys();
+
+  const infoTable = new CLITable({
+    head: [chalk.blue('Name')],
+  });
+
+  list.forEach(name => infoTable.push([name]));
+
+  console.log(infoTable.toString());
+
+  await app.destroy();
+};

package/lib/commands/watchAdmin.js

@@ -1,33 +1,42 @@
 'use strict';
 
-// eslint-disable-next-line node/no-extraneous-require
 const strapiAdmin = require('@strapi/admin');
-const { getOr } = require('lodash/fp');
 const { getConfigUrls, getAbsoluteServerUrl } = require('@strapi/utils');
-const loadConfiguration = require('../core/app-configuration');
+
 const ee = require('../utils/ee');
 const addSlash = require('../utils/addSlash');
+const strapi = require('../index');
+const getEnabledPlugins = require('../core/loaders/plugins/get-enabled-plugins');
 
 module.exports = async function({ browser }) {
   const dir = process.cwd();
 
-  const config = loadConfiguration(dir);
+  const strapiInstance = strapi({
+    dir,
+    autoReload: true,
+    serveAdminPanel: false,
+  });
+
+  const plugins = await getEnabledPlugins(strapiInstance);
+
+  const { adminPath } = getConfigUrls(strapiInstance.config, true);
 
-  const { adminPath } = getConfigUrls(config.server, true);
+  const adminPort = strapiInstance.config.get('admin.port', 8000);
+  const adminHost = strapiInstance.config.get('admin.host', 'localhost');
+  const adminWatchIgnoreFiles = strapiInstance.config.get('admin.watchIgnoreFiles', []);
 
-  const adminPort = getOr(8000, 'server.admin.port')(config);
-  const adminHost = getOr('localhost', 'server.admin.host')(config);
-  const adminWatchIgnoreFiles = getOr([], 'server.admin.watchIgnoreFiles')(config);
+  const backendURL = getAbsoluteServerUrl(strapiInstance.config, true);
 
   ee({ dir });
 
   strapiAdmin.watchAdmin({
     dir,
+    plugins,
     port: adminPort,
     host: adminHost,
     browser,
     options: {
-      backend: getAbsoluteServerUrl(config, true),
+      backend: backendURL,
       adminPath: addSlash(adminPath),
       watchIgnoreFiles: adminWatchIgnoreFiles,
       features: ee.isEE ? ee.features.getEnabled() : [],

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

@@ -10,26 +10,10 @@ 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 { version: strapiVersion } = require(path.join(__dirname, '../../../package.json'));
 
-const CONFIG_PATHS = {
-  admin: 'admin',
-  api: 'api',
-  config: 'config',
-  controllers: 'controllers',
-  models: 'models',
-  plugins: 'plugins',
-  policies: 'policies',
-  tmp: '.tmp',
-  services: 'services',
-  static: 'public',
-  validators: 'validators',
-  views: 'views',
-};
-
 const defaultConfig = {
   server: {
     host: process.env.HOST || os.hostname() || 'localhost',
@@ -39,23 +23,10 @@ const defaultConfig = {
     admin: { autoOpen: false },
   },
   admin: {},
-  middleware: {
-    timeout: 1000,
-    load: {
-      before: ['responseTime', 'logger', 'cors', 'responses', 'gzip'],
-      order: [],
-      after: ['parser', 'router'],
-    },
-    settings: {},
-  },
-  hook: {
-    timeout: 1000,
-    load: {
-      before: ['responseTime', 'logger', 'cors', 'responses', 'gzip'],
-      order: [],
-      after: ['parser', 'router'],
+  api: {
+    rest: {
+      prefix: '/api',
     },
-    settings: {},
   },
 };
 
@@ -68,8 +39,6 @@ module.exports = (dir, initialConfig = {}) => {
 
   const rootConfig = {
     launchedAt: Date.now(),
-    appPath: dir,
-    paths: CONFIG_PATHS,
     serveAdminPanel,
     autoReload,
     environment: process.env.NODE_ENV,
@@ -79,8 +48,6 @@ module.exports = (dir, initialConfig = {}) => {
       ...pkgJSON,
       strapi: strapiVersion,
     },
-    installedMiddlewares: getPrefixedDeps('@strapi/middleware', pkgJSON),
-    installedHooks: getPrefixedDeps('@strapi/hook', pkgJSON),
   };
 
   const baseConfig = omit('plugins', loadConfigDir(configDir)); // plugin config will be loaded later

package/lib/core/bootstrap.js

@@ -0,0 +1,25 @@
+'use strict';
+
+const { getConfigUrls } = require('@strapi/utils');
+
+module.exports = 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;
+  }
+};

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

@@ -2,7 +2,7 @@
 
 const { cloneDeep } = require('lodash/fp');
 const _ = require('lodash');
-const { hasDraftAndPublish } = require('@strapi/utils').contentTypes;
+const { hasDraftAndPublish, getPrivateAttributes } = require('@strapi/utils').contentTypes;
 const {
   CREATED_AT_ATTRIBUTE,
   UPDATED_AT_ATTRIBUTE,
@@ -19,11 +19,11 @@ const createContentType = (uid, definition) => {
     throw new Error(`Content Type Definition is invalid for ${uid}'.\n${e.errors}`);
   }
 
-  const createdContentType = cloneDeep(definition);
+  const { schema, actions, lifecycles } = cloneDeep(definition);
 
   // general info
-  Object.assign(createdContentType.schema, {
-    kind: createdContentType.schema.kind || 'collectionType',
+  Object.assign(schema, {
+    kind: schema.kind || 'collectionType',
     __schema__: pickSchema(definition.schema),
     modelType: 'contentType',
     modelName: definition.schema.info.singularName,
@@ -31,27 +31,26 @@ const createContentType = (uid, definition) => {
   });
 
   if (uid.startsWith('api::')) {
-    Object.assign(createdContentType.schema, {
+    Object.assign(schema, {
       uid,
       apiName: uid.split('::')[1].split('.')[0],
-      collectionName: definition.schema.collectionName || definition.schema.info.singularName,
-      globalId: getGlobalId(definition.schema, definition.schema.info.singularName),
+      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(createdContentType.schema, {
+    Object.assign(schema, {
       uid,
       plugin: pluginName, // TODO: to be set in load-plugins.js
       collectionName:
-        createdContentType.schema.collectionName ||
-        `${pluginName}_${definition.schema.info.singularName}`.toLowerCase(),
-      globalId: getGlobalId(definition.schema, definition.schema.info.singularName, pluginName),
+        schema.collectionName || `${pluginName}_${schema.info.singularName}`.toLowerCase(),
+      globalId: getGlobalId(schema, schema.info.singularName, pluginName),
     });
-  } else if (uid.startsWith('strapi::')) {
-    Object.assign(createdContentType.schema, {
+  } else if (uid.startsWith('admin::')) {
+    Object.assign(schema, {
       uid,
       plugin: 'admin',
-      globalId: getGlobalId(definition.schema, definition.schema.info.singularName, 'admin'),
+      globalId: getGlobalId(schema, schema.info.singularName, 'admin'),
     });
   } else {
     throw new Error(
@@ -59,29 +58,25 @@ const createContentType = (uid, definition) => {
     );
   }
 
-  Object.defineProperty(createdContentType.schema, 'privateAttributes', {
+  Object.defineProperty(schema, 'privateAttributes', {
     get() {
-      // FIXME: to fix
-      // return strapi.getModel(model.uid).privateAttributes;
-      return [];
+      return getPrivateAttributes(schema);
     },
   });
 
   // attributes
-  Object.assign(createdContentType.schema.attributes, {
+  Object.assign(schema.attributes, {
     [CREATED_AT_ATTRIBUTE]: {
       type: 'datetime',
-      default: () => new Date(),
     },
     // TODO: handle on edit set to new date
     [UPDATED_AT_ATTRIBUTE]: {
       type: 'datetime',
-      default: () => new Date(),
     },
   });
 
-  if (hasDraftAndPublish(createdContentType.schema)) {
-    createdContentType.schema.attributes[PUBLISHED_AT_ATTRIBUTE] = {
+  if (hasDraftAndPublish(schema)) {
+    schema.attributes[PUBLISHED_AT_ATTRIBUTE] = {
       type: 'datetime',
       configurable: false,
       writable: true,
@@ -89,12 +84,12 @@ const createContentType = (uid, definition) => {
     };
   }
 
-  const isPrivate = !_.get(createdContentType.schema, 'options.populateCreatorFields', false);
+  const isPrivate = !_.get(schema, 'options.populateCreatorFields', false);
 
-  createdContentType.schema.attributes[CREATED_BY_ATTRIBUTE] = {
+  schema.attributes[CREATED_BY_ATTRIBUTE] = {
     type: 'relation',
     relation: 'oneToOne',
-    target: 'strapi::user',
+    target: 'admin::user',
     configurable: false,
     writable: false,
     visible: false,
@@ -102,10 +97,10 @@ const createContentType = (uid, definition) => {
     private: isPrivate,
   };
 
-  createdContentType.schema.attributes[UPDATED_BY_ATTRIBUTE] = {
+  schema.attributes[UPDATED_BY_ATTRIBUTE] = {
     type: 'relation',
     relation: 'oneToOne',
-    target: 'strapi::user',
+    target: 'admin::user',
     configurable: false,
     writable: false,
     visible: false,
@@ -113,7 +108,9 @@ const createContentType = (uid, definition) => {
     private: isPrivate,
   };
 
-  return createdContentType;
+  Object.assign(schema, { actions, lifecycles });
+
+  return schema;
 };
 
 const getGlobalId = (model, modelName, prefix) => {

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

@@ -3,9 +3,28 @@
 const { keyBy, mapValues } = require('lodash');
 const { yup } = require('@strapi/utils');
 
-// To replace by directly using implemented lifecycles
-const lifecycles = ['beforeCreate', 'afterCreate'];
-const lifecyclesShape = mapValues(keyBy(lifecycles), () =>
+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()

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

@@ -1,12 +1,33 @@
 '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 plugin ${namespace}.\n${e.errors.join('\n')}`);
+    throw new Error(`strapi-server.js is invalid for '${namespace}'.\n${e.errors.join('\n')}`);
   }
 
   const called = {};
@@ -16,21 +37,21 @@ const createModule = (namespace, rawModule, strapi) => {
         throw new Error(`Bootstrap for ${namespace} has already been called`);
       }
       called.bootstrap = true;
-      await rawModule.bootstrap(strapi);
+      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(strapi);
+      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(strapi);
+      await (rawModule.destroy && rawModule.destroy({ strapi }));
     },
     load() {
       strapi.container.get('content-types').add(namespace, rawModule.contentTypes);
@@ -38,38 +59,48 @@ const createModule = (namespace, rawModule, strapi) => {
       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(namespace.replace('::', '.'), rawModule.config);
+      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);
     },
-    routes: rawModule.routes, // TODO: to remove v3
     contentType(ctName) {
       return strapi.container.get('content-types').get(`${namespace}.${ctName}`);
     },
     get contentTypes() {
-      return strapi.container.get('content-types').getAll(namespace);
+      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() {
-      return strapi.container.get('services').getAll(namespace);
+      const services = strapi.container.get('services').getAll(namespace);
+      return removeNamespacedKeys(services, namespace);
     },
     policy(policyName) {
       return strapi.container.get('policies').get(`${namespace}.${policyName}`);
     },
     get policies() {
-      return rawModule.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() {
-      return strapi.container.get('middlewares').getAll(namespace);
+      const middlewares = strapi.container.get('middlewares').getAll(namespace);
+      return removeNamespacedKeys(middlewares, namespace);
     },
     controller(controllerName) {
       return strapi.container.get('controllers').get(`${namespace}.${controllerName}`);
     },
     get controllers() {
-      return rawModule.controllers;
+      const controllers = strapi.container.get('controllers').getAll(namespace);
+      return removeNamespacedKeys(controllers, namespace);
     },
   };
 };

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

@@ -5,25 +5,22 @@ const { yup } = require('@strapi/utils');
 const strapiServerSchema = yup
   .object()
   .shape({
-    bootstrap: yup
-      .mixed()
-      .isFunction()
-      .required(),
-    destroy: yup
-      .mixed()
-      .isFunction()
-      .required(),
-    register: yup
-      .mixed()
-      .isFunction()
-      .required(),
-    config: yup.object().required(),
-    routes: yup.array().required(), // may be removed later
-    controllers: yup.object().required(), // may be removed later
-    services: yup.object().required(),
-    policies: yup.object().required(),
-    middlewares: yup.object().required(), // may be removed later
-    contentTypes: yup.object().required(),
+    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();
 

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));
+};