@strapi/strapi 4.2.0-alpha.0 → 4.2.0-alpha.6

package/bin/strapi.js

@@ -100,7 +100,7 @@ program
 
 // `$ strapi start`
 program
-  .command('start')
+  .command('start [dir]')
   .description('Start your Strapi application')
   .action(getLocalScript('start'));
 
@@ -174,6 +174,16 @@ program
   .action(getLocalScript('configurationRestore'));
 
 // Admin
+program
+  .command('admin:create-user')
+  .alias('admin:create')
+  .description('Create a new admin')
+  .option('-e, --email <email>', 'Email of the new admin')
+  .option('-p, --password <password>', 'Password of the new admin')
+  .option('-f, --firstname <first name>', 'First name of the new admin')
+  .option('-l, --lastname <last name>', 'Last name of the new admin')
+  .action(getLocalScript('admin-create'));
+
 program
   .command('admin:reset-user-password')
   .alias('admin:reset-password')

package/lib/Strapi.js

@@ -1,5 +1,6 @@
 'use strict';
 
+const path = require('path');
 const _ = require('lodash');
 const { isFunction } = require('lodash/fp');
 const { createLogger } = require('@strapi/logger');
@@ -47,12 +48,40 @@ const LIFECYCLES = {
   DESTROY: 'destroy',
 };
 
+/**
+ * Resolve the working directories based on the instance options.
+ *
+ * Behavior:
+ * - `appDir` is the directory where Strapi will write every file (schemas, generated APIs, controllers or services)
+ * - `distDir` is the directory where Strapi will read configurations, schemas and any compiled code
+ *
+ * Default values:
+ * - If `appDir` is `undefined`, it'll be set to `process.cwd()`
+ * - If `distDir` is `undefined`, it'll be set to `appDir`
+ */
+const resolveWorkingDirectories = opts => {
+  const cwd = process.cwd();
+
+  const appDir = opts.appDir ? path.resolve(cwd, opts.appDir) : cwd;
+  const distDir = opts.distDir ? path.resolve(cwd, opts.distDir) : appDir;
+
+  return { appDir, distDir };
+};
+
 class Strapi {
   constructor(opts = {}) {
     destroyOnSignal(this);
-    this.dirs = utils.getDirs(opts.dir || process.cwd());
-    const appConfig = loadConfiguration(this.dirs.root, opts);
+
+    // Create a mapping of every useful directory (both for the app and dist directories)
+    this.dirs = utils.getDirs(resolveWorkingDirectories(opts));
+
+    // Load the app configuration from the dist directory
+    const appConfig = loadConfiguration(this.dirs.dist.root, opts);
+
+    // Instanciate the Strapi container
     this.container = createContainer(this);
+
+    // Register every Strapi registry in the container
     this.container.register('config', createConfigProvider(appConfig));
     this.container.register('content-types', contentTypesRegistry(this));
     this.container.register('services', servicesRegistry(this));
@@ -65,10 +94,14 @@ class Strapi {
     this.container.register('apis', apisRegistry(this));
     this.container.register('auth', createAuth(this));
 
+    // Strapi state management variables
     this.isLoaded = false;
     this.reload = this.reload();
+
+    // Instanciate the Koa app & the HTTP server
     this.server = createServer(this);
 
+    // Strapi utils instanciation
     this.fs = createStrapiFs(this);
     this.eventHub = createEventHub();
     this.startupLogger = createStartupLogger(this);
@@ -84,7 +117,7 @@ class Strapi {
   }
 
   get EE() {
-    return ee({ dir: this.dirs.root, logger: this.log });
+    return ee({ dir: this.dirs.dist.root, logger: this.log });
   }
 
   get services() {
@@ -211,7 +244,6 @@ class Strapi {
       } catch (e) {
         this.telemetry.send('didNotOpenTab');
       }
-     ;
     }
   }
 

package/lib/commands/admin-create.js

@@ -0,0 +1,115 @@
+'use strict';
+
+const { yup } = require('@strapi/utils');
+const _ = require('lodash');
+const inquirer = require('inquirer');
+const strapi = require('../index');
+
+const emailValidator = yup
+  .string()
+  .email('Invalid email address')
+  .lowercase();
+
+const passwordValidator = yup
+  .string()
+  .min(8, 'Password must be at least 8 characters long')
+  .matches(/[a-z]/, 'Password must contain at least one lowercase character')
+  .matches(/[A-Z]/, 'Password must contain at least one uppercase character')
+  .matches(/\d/, 'Password must contain at least one number');
+
+const adminCreateSchema = yup.object().shape({
+  email: emailValidator,
+  password: passwordValidator,
+  firstname: yup.string().required('First name is required'),
+  lastname: yup.string(),
+});
+
+const promptQuestions = [
+  {
+    type: 'input',
+    name: 'email',
+    message: 'Admin email?',
+    async validate(value) {
+      const validEmail = await emailValidator.validate(value);
+      return validEmail === value || validEmail;
+    },
+  },
+  {
+    type: 'password',
+    name: 'password',
+    message: 'Admin password?',
+    async validate(value) {
+      const validPassword = await passwordValidator.validate(value);
+      return validPassword === value || validPassword;
+    },
+  },
+  { type: 'input', name: 'firstname', message: 'First name?' },
+  { type: 'input', name: 'lastname', message: 'Last name?' },
+  {
+    type: 'confirm',
+    name: 'confirm',
+    message: 'Do you really want to create a new admin?',
+  },
+];
+
+/**
+ * Create new admin user
+ * @param {Object} cmdOptions - command options
+ * @param {string} cmdOptions.email - new admin's email
+ * @param {string} [cmdOptions.password] - new admin's password
+ * @param {string} cmdOptions.firstname - new admin's first name
+ * @param {string} [cmdOptions.lastname] - new admin's last name
+ */
+module.exports = async function(cmdOptions = {}) {
+  let { email, password, firstname, lastname } = cmdOptions;
+
+  if (
+    _.isEmpty(email) &&
+    _.isEmpty(password) &&
+    _.isEmpty(firstname) &&
+    _.isEmpty(lastname) &&
+    process.stdin.isTTY
+  ) {
+    const inquiry = await inquirer.prompt(promptQuestions);
+
+    if (!inquiry.confirm) {
+      process.exit(0);
+    }
+
+    ({ email, password, firstname, lastname } = inquiry);
+  }
+
+  try {
+    await adminCreateSchema.validate({ email, password, firstname, lastname });
+  } catch (err) {
+    console.error(err.errors[0]);
+    process.exit(1);
+  }
+
+  return createAdmin({ email, password, firstname, lastname });
+};
+
+async function createAdmin({ email, password, firstname, lastname }) {
+  const app = await strapi().load();
+
+  const user = await app.admin.services.user.exists({ email });
+
+  if (user) {
+    console.error(`User with email "${email}" already exists`);
+    process.exit(1);
+  }
+
+  const superAdminRole = await app.admin.services.role.getSuperAdmin();
+
+  await app.admin.services.user.create({
+    email,
+    firstname,
+    lastname,
+    isActive: true,
+    roles: [superAdminRole.id],
+    ...(password && { password, registrationToken: null }),
+  });
+
+  console.log(`Successfully created new admin`);
+  process.exit(0);
+}

package/lib/commands/build.js

@@ -1,56 +1,31 @@
 'use strict';
-const { green } = require('chalk');
+const path = require('path');
 
-const strapiAdmin = require('@strapi/admin');
-const { getConfigUrls } = require('@strapi/utils');
-
-const ee = require('../utils/ee');
-const addSlash = require('../utils/addSlash');
-const strapi = require('../index');
-const getEnabledPlugins = require('../core/loaders/plugins/get-enabled-plugins');
+const tsUtils = require('@strapi/typescript-utils');
+const { buildAdmin, buildTypeScript } = require('./builders');
 
 /**
  * `$ strapi build`
  */
 module.exports = async ({ optimization, forceBuild = true }) => {
-  const dir = process.cwd();
-
-  const strapiInstance = strapi({
-    dir,
-    autoReload: true,
-    serveAdminPanel: false,
-  });
+  let buildDestDir = process.cwd();
+  const srcDir = process.cwd();
 
-  const plugins = await getEnabledPlugins(strapiInstance);
+  const isTSProject = await tsUtils.isTypeScriptProject(srcDir);
 
-  const env = strapiInstance.config.get('environment');
-  const { serverUrl, adminPath } = getConfigUrls(strapiInstance.config, true);
+  // Typescript
+  if (isTSProject) {
+    await buildTypeScript({ srcDir, watch: false });
 
-  console.log(`Building your admin UI with ${green(env)} configuration ...`);
+    // Update the dir path for the next steps
+    buildDestDir = path.join(srcDir, 'dist');
+  }
 
-  // Always remove the .cache and build folders
-  await strapiAdmin.clean({ dir });
-
-  ee({ dir });
-
-  return strapiAdmin
-    .build({
-      forceBuild,
-      dir,
-      plugins,
-      // front end build env is always production for now
-      env: 'production',
-      optimize: optimization,
-      options: {
-        backend: serverUrl,
-        adminPath: addSlash(adminPath),
-      },
-    })
-    .then(() => {
-      console.log('Admin UI built successfully');
-    })
-    .catch(err => {
-      console.error(err);
-      process.exit(1);
-    });
+  await buildAdmin({
+    buildDestDir,
+    forceBuild,
+    isTSProject,
+    optimization,
+    srcDir,
+  });
 };

package/lib/commands/builders/admin.js

@@ -0,0 +1,58 @@
+'use strict';
+
+const { green } = require('chalk');
+
+const strapiAdmin = require('@strapi/admin');
+const { getConfigUrls } = require('@strapi/utils');
+
+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 ({ buildDestDir, forceBuild = true, isTSProject, optimization, srcDir }) => {
+  const strapiInstance = strapi({
+    // TODO check if this is working @convly
+    distDir: buildDestDir,
+    autoReload: true,
+    serveAdminPanel: false,
+  });
+
+  const plugins = await getEnabledPlugins(strapiInstance);
+
+  const env = strapiInstance.config.get('environment');
+  const { serverUrl, adminPath } = getConfigUrls(strapiInstance.config, true);
+
+  console.log(`Building your admin UI with ${green(env)} configuration...`);
+
+  // Always remove the .cache and build folders
+  // FIXME the BE should remove the build dir and the admin should only
+  // be responsible of removing the .cache dir.
+  await strapiAdmin.clean({ appDir: srcDir, buildDestDir });
+
+  // @convly shouldn't we use the app dir here?
+  ee({ dir: buildDestDir });
+
+  return strapiAdmin
+    .build({
+      appDir: srcDir,
+      buildDestDir,
+      // front end build env is always production for now
+      env: 'production',
+      forceBuild,
+      plugins,
+      optimize: optimization,
+      options: {
+        backend: serverUrl,
+        adminPath: addSlash(adminPath),
+      },
+      useTypeScript: isTSProject,
+    })
+    .then(() => {
+      console.log('Admin UI built successfully');
+    })
+    .catch(err => {
+      console.error(err);
+      process.exit(1);
+    });
+};

package/lib/commands/builders/index.js

@@ -0,0 +1,9 @@
+'use strict';
+
+const buildAdmin = require('./admin');
+const buildTypeScript = require('./typescript');
+
+module.exports = {
+  buildAdmin,
+  buildTypeScript,
+};

package/lib/commands/builders/typescript.js

@@ -0,0 +1,35 @@
+'use strict';
+
+const path = require('path');
+const fs = require('fs-extra');
+const tsUtils = require('@strapi/typescript-utils');
+
+const cleanupDistDirectory = async distDir => {
+  if (!await fs.pathExists(distDir)){
+    return 
+  }
+
+  const dirContent = await fs.readdir(distDir);
+  const validFilenames = dirContent
+    // Ignore the admin build folder
+    .filter(filename => filename !== 'build');
+
+
+  for (const filename of validFilenames) {
+    await fs.remove(path.resolve(distDir, filename));
+  }
+};
+
+module.exports = async ({ srcDir, distDir, watch = false }) => {
+  const isTSProject = await tsUtils.isTypeScriptProject(srcDir);
+
+  if (!isTSProject) {
+    throw new Error(`tsconfig file not found in ${srcDir}`);
+  }
+
+  
+
+  await cleanupDistDirectory(distDir);
+
+  return tsUtils.compile(srcDir, { watch });
+};

package/lib/commands/develop.js

@@ -6,114 +6,150 @@ const fs = require('fs-extra');
 const chokidar = require('chokidar');
 const execa = require('execa');
 const { getOr } = require('lodash/fp');
+const tsUtils = require('@strapi/typescript-utils');
 
-const { createLogger } = require('@strapi/logger');
 const loadConfiguration = require('../core/app-configuration');
 const strapi = require('../index');
-const buildAdmin = require('./build');
+const { buildTypeScript, buildAdmin } = require('./builders');
 
 /**
  * `$ strapi develop`
  *
  */
+
 module.exports = async function({ build, watchAdmin, polling, browser }) {
-  const dir = process.cwd();
-  const config = loadConfiguration(dir);
-  const logger = createLogger(config.logger, {});
+  const appDir = process.cwd();
+
+  const isTSProject = await tsUtils.isTypeScriptProject(appDir);
+  const distDir = isTSProject ? path.join(appDir, 'dist') : appDir;
 
   try {
     if (cluster.isMaster || cluster.isPrimary) {
-      const serveAdminPanel = getOr(true, 'admin.serveAdminPanel')(config);
-
-      const buildExists = fs.existsSync(path.join(dir, 'build'));
-      // Don't run the build process if the admin is in watch mode
-      if (build && !watchAdmin && serveAdminPanel && !buildExists) {
-        try {
-          await buildAdmin({ optimization: false, forceBuild: false });
-        } catch (err) {
-          process.exit(1);
-        }
-      }
-
-      if (watchAdmin) {
-        try {
-          execa('npm', ['run', '-s', 'strapi', 'watch-admin', '--', '--browser', browser], {
-            stdio: 'inherit',
-          });
-        } catch (err) {
-          process.exit(1);
-        }
-      }
-
-      cluster.on('message', (worker, message) => {
-        switch (message) {
-          case 'reload':
-            logger.info('The server is restarting\n');
-            worker.send('kill');
-            break;
-          case 'killed':
-            cluster.fork();
-            break;
-          case 'stop':
-            process.exit(1);
-          default:
-            return;
-        }
+      return primaryProcess({
+        distDir,
+        appDir,
+        build,
+        browser,
+        isTSProject,
+        watchAdmin,
       });
-
-      cluster.fork();
     }
 
     if (cluster.isWorker) {
-      const strapiInstance = strapi({
-        dir,
-        autoReload: true,
-        serveAdminPanel: watchAdmin ? false : true,
+      return workerProcess({ appDir, distDir, watchAdmin, polling, isTSProject });
+    }
+  } catch (e) {
+    console.error(e);
+    process.exit(1);
+  }
+};
+
+const primaryProcess = async ({ distDir, appDir, build, isTSProject, watchAdmin, browser }) => {
+  if (isTSProject) {
+    await buildTypeScript({ srcDir: appDir, distDir, watch: false });
+  }
+
+  const config = loadConfiguration(distDir);
+  const serveAdminPanel = getOr(true, 'admin.serveAdminPanel')(config);
+
+  const buildExists = fs.existsSync(path.join(distDir, 'build'));
+
+  // Don't run the build process if the admin is in watch mode
+  if (build && !watchAdmin && serveAdminPanel && !buildExists) {
+    try {
+      await buildAdmin({
+        buildDestDir: distDir,
+        forceBuild: false,
+        isTSProject,
+        optimization: false,
+        srcDir: appDir,
       });
+    } catch (err) {
+      process.exit(1);
+    }
+  }
 
-      const adminWatchIgnoreFiles = getOr([], 'admin.watchIgnoreFiles')(config);
-      watchFileChanges({
-        dir,
-        strapiInstance,
-        watchIgnoreFiles: adminWatchIgnoreFiles,
-        polling,
+  if (watchAdmin) {
+    try {
+      execa('npm', ['run', '-s', 'strapi', 'watch-admin', '--', '--browser', browser], {
+        stdio: 'inherit',
       });
+    } catch (err) {
+      process.exit(1);
+    }
+  }
 
-      process.on('message', async message => {
-        switch (message) {
-          case 'kill':
-            await strapiInstance.destroy();
-            process.send('killed');
-            process.exit();
-          default:
-          // Do nothing.
+  cluster.on('message', async (worker, message) => {
+    switch (message) {
+      case 'reload':
+        if (isTSProject) {
+          await buildTypeScript({ srcDir: appDir, distDir, watch: false });
         }
-      });
 
-      return strapiInstance.start();
+        console.info('The server is restarting\n');
+
+        worker.send('kill');
+        break;
+      case 'killed':
+        cluster.fork();
+        break;
+      case 'stop':
+        process.exit(1);
+      default:
+        return;
     }
-  } catch (e) {
-    logger.error(e);
-    process.exit(1);
-  }
+  });
+
+  cluster.fork();
+};
+
+const workerProcess = ({ appDir, distDir, watchAdmin, polling, isTSProject }) => {
+  const strapiInstance = strapi({
+    distDir,
+    autoReload: true,
+    serveAdminPanel: watchAdmin ? false : true,
+  });
+
+  const adminWatchIgnoreFiles = strapiInstance.config.get('admin.watchIgnoreFiles', []);
+  watchFileChanges({
+    appDir,
+    strapiInstance,
+    watchIgnoreFiles: adminWatchIgnoreFiles,
+    polling,
+    isTSProject,
+  });
+
+  process.on('message', async message => {
+    switch (message) {
+      case 'kill':
+        await strapiInstance.destroy();
+        process.send('killed');
+        process.exit();
+      default:
+      // Do nothing.
+    }
+  });
+
+  return strapiInstance.start();
 };
 
 /**
  * Init file watching to auto restart strapi app
  * @param {Object} options - Options object
- * @param {string} options.dir - This is the path where the app is located, the watcher will watch the files under this folder
+ * @param {string} options.appDir - This is the path where the app is located, the watcher will watch the files under this folder
  * @param {Strapi} options.strapi - Strapi instance
  * @param {array} options.watchIgnoreFiles - Array of custom file paths that should not be watched
  */
-function watchFileChanges({ dir, strapiInstance, watchIgnoreFiles, polling }) {
-  const restart = () => {
+function watchFileChanges({ appDir, strapiInstance, watchIgnoreFiles, polling }) {
+  const restart = async () => {
     if (strapiInstance.reload.isWatching && !strapiInstance.reload.isReloading) {
       strapiInstance.reload.isReloading = true;
       strapiInstance.reload();
     }
   };
 
-  const watcher = chokidar.watch(dir, {
+  // @soupette should we keep watching the dist dir (for the watch admin?)
+  const watcher = chokidar.watch(appDir, {
     ignoreInitial: true,
     usePolling: polling,
     ignored: [
@@ -133,6 +169,7 @@ function watchFileChanges({ dir, strapiInstance, watchIgnoreFiles, polling }) {
       '**/public/**',
       '**/*.db*',
       '**/exports/**',
+      '**/dist/**',
       ...watchIgnoreFiles,
     ],
   });

package/lib/commands/start.js

@@ -5,4 +5,4 @@ const strapi = require('../index');
 /**
  * `$ strapi start`
  */
-module.exports = () => strapi().start();
+module.exports = distDir => strapi({ distDir }).start();

package/lib/commands/watchAdmin.js

@@ -1,18 +1,22 @@
 'use strict';
 
+const path = require('path');
 const strapiAdmin = require('@strapi/admin');
+const tsUtils = require('@strapi/typescript-utils');
 const { getConfigUrls, getAbsoluteServerUrl } = require('@strapi/utils');
 
-const ee = require('../utils/ee');
+const getEnabledPlugins = require('../core/loaders/plugins/get-enabled-plugins');
 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 currentDirectory = process.cwd();
+
+  const isTSProject = await tsUtils.isTypeScriptProject(currentDirectory);
+  const buildDestDir = isTSProject ? path.join(currentDirectory, 'dist') : currentDirectory;
 
   const strapiInstance = strapi({
-    dir,
+    distDir: buildDestDir,
     autoReload: true,
     serveAdminPanel: false,
   });
@@ -23,14 +27,12 @@ module.exports = async function({ browser }) {
 
   const adminPort = strapiInstance.config.get('admin.port', 8000);
   const adminHost = strapiInstance.config.get('admin.host', 'localhost');
-  const adminWatchIgnoreFiles = strapiInstance.config.get('admin.watchIgnoreFiles', []);
 
   const backendURL = getAbsoluteServerUrl(strapiInstance.config, true);
 
-  ee({ dir });
-
   strapiAdmin.watchAdmin({
-    dir,
+    appDir: currentDirectory,
+    buildDestDir,
     plugins,
     port: adminPort,
     host: adminHost,
@@ -38,8 +40,7 @@ module.exports = async function({ browser }) {
     options: {
       backend: backendURL,
       adminPath: addSlash(adminPath),
-      watchIgnoreFiles: adminWatchIgnoreFiles,
-      features: ee.isEE ? ee.features.getEnabled() : [],
     },
+    useTypeScript: isTSProject,
   });
 };

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

@@ -4,9 +4,11 @@ const path = require('path');
 const fs = require('fs');
 const { templateConfiguration, env } = require('@strapi/utils');
 
+const __importDefault = require('../../utils/import-default');
+
 const loadJsFile = file => {
   try {
-    const jsModule = require(file);
+    const jsModule = __importDefault(require(file)).default;
 
     // call if function
     if (typeof jsModule === 'function') {

package/lib/core/loaders/apis.js

@@ -5,6 +5,7 @@ const { existsSync } = require('fs-extra');
 const _ = require('lodash');
 const fse = require('fs-extra');
 const { isKebabCase } = require('@strapi/utils');
+const { importDefault } = require('../../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));
@@ -16,18 +17,18 @@ const DEFAULT_CONTENT_TYPE = {
 };
 
 module.exports = async strapi => {
-  if (!existsSync(strapi.dirs.api)) {
-    throw new Error('Missing api folder. Please create one at `./src/api`');
+  if (!existsSync(strapi.dirs.dist.api)) {
+    return;
   }
 
-  const apisFDs = await fse.readdir(strapi.dirs.api, { withFileTypes: true });
+  const apisFDs = await fse.readdir(strapi.dirs.dist.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));
+      const api = await loadAPI(join(strapi.dirs.dist.api, apiFD.name));
 
       apis[apiName] = api;
     }
@@ -150,7 +151,7 @@ const loadFile = file => {
 
   switch (ext) {
     case '.js':
-      return require(file);
+      return importDefault(require(file)).default;
     case '.json':
       return fse.readJSON(file);
     default:

package/lib/core/loaders/components.js

@@ -6,19 +6,20 @@ const { pathExists } = require('fs-extra');
 const loadFiles = require('../../load/load-files');
 
 module.exports = async strapi => {
-  if (!(await pathExists(strapi.dirs.components))) {
+  if (!(await pathExists(strapi.dirs.dist.components))) {
     return {};
   }
 
-  const map = await loadFiles(strapi.dirs.components, '*/*.*(js|json)');
+  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];
 
-      const filePath = join(strapi.dirs.components, category, schema.__filename__);
-
       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}.`
         );

package/lib/core/loaders/middlewares.js

@@ -3,17 +3,19 @@
 const { join, extname, basename } = require('path');
 const fse = require('fs-extra');
 
+const { importDefault } = require('../../utils');
+
 // 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');
+  const internalMiddlewares = importDefault(require('../../middlewares')).default;
 
   strapi.container.get('middlewares').add(`global::`, localMiddlewares);
   strapi.container.get('middlewares').add(`strapi::`, internalMiddlewares);
 };
 
 const loadLocalMiddlewares = async strapi => {
-  const dir = strapi.dirs.middlewares;
+  const dir = strapi.dirs.dist.middlewares;
 
   if (!(await fse.pathExists(dir))) {
     return {};
@@ -28,7 +30,7 @@ const loadLocalMiddlewares = async strapi => {
 
     if (fd.isFile() && extname(name) === '.js') {
       const key = basename(name, '.js');
-      middlewares[key] = require(fullPath);
+      middlewares[key] = importDefault(require(fullPath)).default;
     }
   }
 

package/lib/core/loaders/plugins/get-enabled-plugins.js

@@ -29,10 +29,15 @@ const toDetailedDeclaration = declaration => {
   let detailedDeclaration = pick(['enabled'], declaration);
   if (has('resolve', declaration)) {
     let pathToPlugin = '';
+    let appPathToPlugin = '';
+
     try {
       pathToPlugin = dirname(require.resolve(declaration.resolve));
+      appPathToPlugin = pathToPlugin;
     } catch (e) {
-      pathToPlugin = resolve(strapi.dirs.root, declaration.resolve);
+      // FIXME: It'll break for resolve paths that are located outside the project files
+      pathToPlugin = resolve(strapi.dirs.dist.root, declaration.resolve);
+      appPathToPlugin = resolve(strapi.dirs.app.root, declaration.resolve);
 
       if (!existsSync(pathToPlugin) || !statSync(pathToPlugin).isDirectory()) {
         throw new Error(`${declaration.resolve} couldn't be resolved`);
@@ -40,6 +45,7 @@ const toDetailedDeclaration = declaration => {
     }
 
     detailedDeclaration.pathToPlugin = pathToPlugin;
+    detailedDeclaration.appPathToPlugin = appPathToPlugin;
   }
   return detailedDeclaration;
 };

package/lib/core/loaders/plugins/get-user-plugins-config.js

@@ -12,9 +12,9 @@ const loadConfigFile = require('../../app-configuration/load-config-file');
  * @return {Promise<{}>}
  */
 const getUserPluginsConfig = async () => {
-  const globalUserConfigPath = join(strapi.dirs.config, 'plugins.js');
+  const globalUserConfigPath = join(strapi.dirs.dist.config, 'plugins.js');
   const currentEnvUserConfigPath = join(
-    strapi.dirs.config,
+    strapi.dirs.dist.config,
     'env',
     process.env.NODE_ENV,
     'plugins.js'

package/lib/core/loaders/plugins/index.js

@@ -26,7 +26,7 @@ const defaultPlugin = {
 };
 
 const applyUserExtension = async plugins => {
-  const extensionsDir = strapi.dirs.extensions;
+  const extensionsDir = strapi.dirs.dist.extensions;
   if (!(await fse.pathExists(extensionsDir))) {
     return;
   }

package/lib/core/loaders/policies.js

@@ -3,9 +3,11 @@
 const { join, extname, basename } = require('path');
 const fse = require('fs-extra');
 
+const { importDefault } = require('../../utils');
+
 // TODO:: allow folders with index.js inside for bigger policies
 module.exports = async function loadPolicies(strapi) {
-  const dir = strapi.dirs.policies;
+  const dir = strapi.dirs.dist.policies;
 
   if (!(await fse.pathExists(dir))) {
     return;
@@ -20,7 +22,7 @@ module.exports = async function loadPolicies(strapi) {
 
     if (fd.isFile() && extname(name) === '.js') {
       const key = basename(name, '.js');
-      policies[key] = require(fullPath);
+      policies[key] = importDefault(require(fullPath)).default;
     }
   }
 

package/lib/core/loaders/src-index.js

@@ -4,6 +4,8 @@ const { resolve } = require('path');
 const { statSync, existsSync } = require('fs');
 const { yup } = require('@strapi/utils');
 
+const { importDefault } = require('../../utils');
+
 const srcSchema = yup
   .object()
   .shape({
@@ -18,16 +20,16 @@ const validateSrcIndex = srcIndex => {
 };
 
 module.exports = strapi => {
-  if (!existsSync(strapi.dirs.src)) {
-    throw new Error('Missing src folder. Please create one at `./src`');
+  if (!existsSync(strapi.dirs.dist.src)) {
+    return;
   }
 
-  const pathToSrcIndex = resolve(strapi.dirs.src, 'index.js');
+  const pathToSrcIndex = resolve(strapi.dirs.dist.src, 'index.js');
   if (!existsSync(pathToSrcIndex) || statSync(pathToSrcIndex).isDirectory()) {
     return {};
   }
 
-  const srcIndex = require(pathToSrcIndex);
+  const srcIndex = importDefault(require(pathToSrcIndex)).default;
 
   try {
     validateSrcIndex(srcIndex);

package/lib/factories.d.ts

@@ -43,6 +43,6 @@ interface Router {
   routes: Route[];
 }
 
-export function createCoreRouter(uid: string, cfg: RouterConfig): () => Router;
-export function createCoreController(uid: string, cfg: ControllerConfig): () => Controller;
-export function createCoreService(uid: string, cfg: ServiceConfig): () => Service;
+export function createCoreRouter(uid: string, cfg?: RouterConfig = {}): () => Router;
+export function createCoreController(uid: string, cfg?: ControllerConfig = {}): () => Controller;
+export function createCoreService(uid: string, cfg?: ServiceConfig = {}): () => Service;

package/lib/load/load-files.js

@@ -3,6 +3,8 @@
 const path = require('path');
 const _ = require('lodash');
 const fse = require('fs-extra');
+
+const { importDefault } = require('../utils');
 const glob = require('./glob');
 const filePathToPath = require('./filepath-to-prop-path');
 
@@ -34,7 +36,7 @@ const loadFiles = async (
     if (path.extname(absolutePath) === '.json') {
       mod = await fse.readJson(absolutePath);
     } else {
-      mod = requireFn(absolutePath);
+      mod = importDefault(requireFn(absolutePath)).default;
     }
 
     Object.defineProperty(mod, '__filename__', {

package/lib/middlewares/favicon.js

@@ -15,5 +15,5 @@ const defaults = {
 module.exports = (config, { strapi }) => {
   const { maxAge, path: faviconPath } = defaultsDeep(defaults, config);
 
-  return favicon(resolve(strapi.dirs.root, faviconPath), { maxAge });
+  return favicon(resolve(strapi.dirs.app.root, faviconPath), { maxAge });
 };

package/lib/middlewares/public/index.js

@@ -71,6 +71,7 @@ module.exports = (config, { strapi }) => {
       {
         method: 'GET',
         path: '/assets/images/(.*)',
+        // Why do we use the __dirname and not strapi.dirs here? @alexandrebodin
         handler: serveStatic(path.resolve(__dirname, 'assets/images'), {
           maxage: maxAge,
           defer: true,
@@ -80,7 +81,7 @@ module.exports = (config, { strapi }) => {
       {
         method: 'GET',
         path: '/(.*)',
-        handler: koaStatic(strapi.dirs.public, {
+        handler: koaStatic(strapi.dirs.app.public, {
           maxage: maxAge,
           defer: true,
         }),

package/lib/services/fs.js

@@ -12,7 +12,7 @@ module.exports = strapi => {
 
     const normalizedPath = path.normalize(filePath).replace(/^\/?(\.\/|\.\.\/)+/, '');
 
-    return path.resolve(strapi.dirs.root, normalizedPath);
+    return path.resolve(strapi.dirs.app.root, normalizedPath);
   }
 
   const strapiFS = {

package/lib/services/metrics/index.js

@@ -90,7 +90,7 @@ const hashProject = strapi =>
 
 const hashDep = strapi => {
   const depStr = JSON.stringify(strapi.config.info.dependencies);
-  const readmePath = path.join(strapi.dirs.root, 'README.md');
+  const readmePath = path.join(strapi.dirs.app.root, 'README.md');
 
   try {
     if (fs.existsSync(readmePath)) {

package/lib/services/server/middleware.js

@@ -112,7 +112,7 @@ const resolveCustomMiddleware = (resolve, strapi) => {
     modulePath = require.resolve(resolve);
   } catch (error) {
     if (error.code === 'MODULE_NOT_FOUND') {
-      modulePath = path.resolve(strapi.dirs.root, resolve);
+      modulePath = path.resolve(strapi.dirs.dist.root, resolve);
     } else {
       throw error;
     }

package/lib/utils/get-dirs.js

@@ -2,16 +2,29 @@
 
 const { join } = require('path');
 
-const getDirs = root => ({
-  root,
-  src: join(root, 'src'),
-  api: join(root, 'src', 'api'),
-  components: join(root, 'src', 'components'),
-  extensions: join(root, 'src', 'extensions'),
-  policies: join(root, 'src', 'policies'),
-  middlewares: join(root, 'src', 'middlewares'),
-  config: join(root, 'config'),
-  public: join(root, 'public'),
+const getDirs = ({ appDir, distDir }) => ({
+  dist: {
+    root: distDir,
+    src: join(distDir, 'src'),
+    api: join(distDir, 'src', 'api'),
+    components: join(distDir, 'src', 'components'),
+    extensions: join(distDir, 'src', 'extensions'),
+    policies: join(distDir, 'src', 'policies'),
+    middlewares: join(distDir, 'src', 'middlewares'),
+    config: join(distDir, 'config'),
+    public: join(distDir, 'public'),
+  },
+  app: {
+    root: appDir,
+    src: join(appDir, 'src'),
+    api: join(appDir, 'src', 'api'),
+    components: join(appDir, 'src', 'components'),
+    extensions: join(appDir, 'src', 'extensions'),
+    policies: join(appDir, 'src', 'policies'),
+    middlewares: join(appDir, 'src', 'middlewares'),
+    config: join(appDir, 'config'),
+    public: join(appDir, 'public'),
+  },
 });
 
 module.exports = getDirs;

package/lib/utils/import-default.js

@@ -0,0 +1,9 @@
+'use strict';
+
+const __importDefault =
+  (this && this.__importDefault) ||
+  function(mod) {
+    return mod && mod.__esModule ? mod : { default: mod };
+  };
+
+module.exports = __importDefault;

package/lib/utils/index.js

@@ -3,9 +3,11 @@
 const openBrowser = require('./open-browser');
 const isInitialized = require('./is-initialized');
 const getDirs = require('./get-dirs');
+const importDefault = require('./import-default');
 
 module.exports = {
   isInitialized,
   openBrowser,
   getDirs,
+  importDefault,
 };

package/lib/utils/update-notifier/index.js

@@ -38,7 +38,7 @@ const createUpdateNotifier = strapi => {
     config = new Configstore(
       pkg.name,
       {},
-      { configPath: path.join(strapi.dirs.root, '.strapi-updater.json') }
+      { configPath: path.join(strapi.dirs.app.root, '.strapi-updater.json') }
     );
   } catch {
     // we don't have write access to the file system

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strapi/strapi",
-  "version": "4.2.0-alpha.0",
+  "version": "4.2.0-alpha.6",
   "description": "An open source headless CMS solution to create and manage your own API. It provides a powerful dashboard and features to make your life easier. Databases supported: MySQL, MariaDB, PostgreSQL, SQLite",
   "keywords": [
     "strapi",
@@ -80,17 +80,16 @@
   "dependencies": {
     "@koa/cors": "3.1.0",
     "@koa/router": "10.1.1",
-    "@strapi/admin": "4.2.0-alpha.0",
-    "@strapi/database": "4.2.0-alpha.0",
-    "@strapi/generate-new": "4.2.0-alpha.0",
-    "@strapi/generators": "4.2.0-alpha.0",
-    "@strapi/logger": "4.2.0-alpha.0",
-    "@strapi/plugin-content-manager": "4.2.0-alpha.0",
-    "@strapi/plugin-content-type-builder": "4.2.0-alpha.0",
-    "@strapi/plugin-email": "4.2.0-alpha.0",
-    "@strapi/plugin-upload": "4.2.0-alpha.0",
-    "@strapi/utils": "4.2.0-alpha.0",
-    "bcryptjs": "2.4.3",
+    "@strapi/database": "4.2.0-alpha.6",
+    "@strapi/generate-new": "4.2.0-alpha.6",
+    "@strapi/generators": "4.2.0-alpha.6",
+    "@strapi/logger": "4.2.0-alpha.6",
+    "@strapi/plugin-content-manager": "4.2.0-alpha.6",
+    "@strapi/plugin-content-type-builder": "4.2.0-alpha.6",
+    "@strapi/plugin-email": "4.2.0-alpha.6",
+    "@strapi/plugin-upload": "4.2.0-alpha.6",
+    "@strapi/typescript-utils": "4.2.0-alpha.6",
+    "@strapi/utils": "4.2.0-alpha.6",
     "boxen": "5.1.2",
     "chalk": "4.1.2",
     "chokidar": "3.5.2",
@@ -130,11 +129,12 @@
     "uuid": "^3.3.2"
   },
   "devDependencies": {
-    "supertest": "^6.1.6"
+    "supertest": "^6.1.6",
+    "typescript": "4.6.2"
   },
   "engines": {
     "node": ">=12.22.0 <=16.x.x",
     "npm": ">=6.0.0"
   },
-  "gitHead": "0e1f1ae08565a5f2427753582f37645a43c00cb2"
+  "gitHead": "0ec01b421912ac3248487ec7c5ad97cf16be6284"
 }