@strapi/strapi 4.2.0-alpha.O → 4.2.0-beta.2

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 { joinBy } = require('@strapi/utils');
+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.isUsingTypeScript(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({ appDir, 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,
+        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: [
@@ -121,6 +157,9 @@ function watchFileChanges({ dir, strapiInstance, watchIgnoreFiles, polling }) {
       /tmp/,
       '**/src/admin/**',
       '**/src/plugins/**/admin/**',
+      // FIXME pass the plugin path to the strapiAdmin.build and strapiAdmin.watch in order to stop copying
+      // the FE files when using TS
+      '**/dist/src/plugins/test/admin/**',
       '**/documentation',
       '**/documentation/**',
       '**/node_modules',
@@ -131,8 +170,11 @@ function watchFileChanges({ dir, strapiInstance, watchIgnoreFiles, polling }) {
       '**/index.html',
       '**/public',
       '**/public/**',
+      strapiInstance.dirs.static.public,
+      joinBy('/', strapiInstance.dirs.static.public, '**'),
       '**/*.db*',
       '**/exports/**',
+      '**/dist/**',
       ...watchIgnoreFiles,
     ],
   });

package/lib/commands/opt-out-telemetry.js

@@ -0,0 +1,83 @@
+'use strict';
+
+const { resolve } = require('path');
+const fse = require('fs-extra');
+const chalk = require('chalk');
+const fetch = require('node-fetch');
+const machineID = require('../utils/machine-id');
+
+const readPackageJSON = async path => {
+  try {
+    const packageObj = await fse.readJson(path);
+    const uuid = packageObj.strapi ? packageObj.strapi.uuid : null;
+
+    return { uuid, packageObj };
+  } catch (err) {
+    console.error(`${chalk.red('Error')}: ${err.message}`);
+  }
+};
+
+const writePackageJSON = async (path, file, spacing) => {
+  try {
+    await fse.writeJson(path, file, { spaces: spacing });
+    return true;
+  } catch (err) {
+    console.error(`${chalk.red('Error')}: ${err.message}`);
+  }
+};
+
+const sendEvent = async uuid => {
+  try {
+    await fetch('https://analytics.strapi.io/track', {
+      method: 'POST',
+      body: JSON.stringify({
+        event: 'didOptOutTelemetry',
+        uuid,
+        deviceId: machineID(),
+      }),
+      headers: { 'Content-Type': 'application/json' },
+    });
+  } catch (e) {
+    //...
+  }
+};
+
+module.exports = async function optOutTelemetry() {
+  const packageJSONPath = resolve(process.cwd(), 'package.json');
+  const exists = await fse.pathExists(packageJSONPath);
+
+  if (!exists) {
+    console.log(`${chalk.yellow('Warning')}: could not find package.json`);
+    process.exit(0);
+  }
+
+  const { uuid, packageObj } = await readPackageJSON(packageJSONPath);
+
+  if ((packageObj.strapi && packageObj.strapi.telemetryDisabled) || !uuid) {
+    console.log(`${chalk.yellow('Warning:')} telemetry is already disabled`);
+    process.exit(0);
+  }
+
+  const updatedPackageJSON = {
+    ...packageObj,
+    strapi: {
+      ...packageObj.strapi,
+      telemetryDisabled: true,
+    },
+  };
+
+  const write = await writePackageJSON(packageJSONPath, updatedPackageJSON, 2);
+
+  if (!write) {
+    console.log(
+      `${chalk.yellow(
+        'Warning'
+      )}: There has been an error, please set "telemetryDisabled": true in the "strapi" object of your package.json manually.`
+    );
+    process.exit(0);
+  }
+
+  await sendEvent(uuid);
+  console.log(`${chalk.green('Successfully opted out of Strapi telemetry')}`);
+  process.exit(0);
+};

package/lib/commands/routes/list.js

@@ -1,13 +1,20 @@
 'use strict';
 
+const path = require('path');
 const CLITable = require('cli-table3');
 const chalk = require('chalk');
 const { toUpper } = require('lodash/fp');
+const tsUtils = require('@strapi/typescript-utils');
 
 const strapi = require('../../index');
 
 module.exports = async function() {
-  const app = await strapi().load();
+  const appDir = process.cwd();
+
+  const isTSProject = await tsUtils.isUsingTypeScript(appDir);
+  const distDir = isTSProject ? path.join(appDir, 'dist') : appDir;
+
+  const app = await strapi({ appDir, distDir }).load();
 
   const list = app.server.listRoutes();
 

package/lib/commands/start.js

@@ -1,8 +1,14 @@
 'use strict';
-
+const tsUtils = require('@strapi/typescript-utils')
 const strapi = require('../index');
 
 /**
  * `$ strapi start`
  */
-module.exports = () => strapi().start();
+module.exports = async specifiedDir => {
+    const appDir = process.cwd();
+    const isTSProject = await tsUtils.isUsingTypeScript(appDir)
+    const distDir = isTSProject && !specifiedDir ? 'dist' : specifiedDir;
+
+    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.isUsingTypeScript(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,6 @@ module.exports = async function({ browser }) {
     options: {
       backend: backendURL,
       adminPath: addSlash(adminPath),
-      watchIgnoreFiles: adminWatchIgnoreFiles,
-      features: ee.isEE ? ee.features.getEnabled() : [],
     },
   });
 };

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

@@ -21,6 +21,7 @@ const defaultConfig = {
     proxy: false,
     cron: { enabled: false },
     admin: { autoOpen: false },
+    dirs: { public: './public' },
   },
   admin: {},
   api: {
@@ -30,12 +31,13 @@ const defaultConfig = {
   },
 };
 
-module.exports = (dir, initialConfig = {}) => {
+module.exports = (dirs, initialConfig = {}) => {
+  const { appDir, distDir } = dirs;
   const { autoReload = false, serveAdminPanel = true } = initialConfig;
 
-  const pkgJSON = require(path.resolve(dir, 'package.json'));
+  const pkgJSON = require(path.resolve(appDir, 'package.json'));
 
-  const configDir = path.resolve(dir || process.cwd(), 'config');
+  const configDir = path.resolve(distDir || process.cwd(), 'config');
 
   const rootConfig = {
     launchedAt: Date.now(),

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/bootstrap.js

@@ -1,8 +1,9 @@
 'use strict';
 
 const { getConfigUrls } = require('@strapi/utils');
+const fse = require('fs-extra');
 
-module.exports = function({ strapi }) {
+module.exports = async function({ strapi }) {
   strapi.config.port = strapi.config.get('server.port') || strapi.config.port;
   strapi.config.host = strapi.config.get('server.host') || strapi.config.host;
 
@@ -22,4 +23,11 @@ module.exports = function({ strapi }) {
   if (!shouldServeAdmin) {
     strapi.config.serveAdminPanel = false;
   }
+
+  // ensure public repository exists
+  if (!(await fse.pathExists(strapi.dirs.static.public))) {
+    throw new Error(
+      `The public folder (${strapi.dirs.static.public}) doesn't exist or is not accessible. Please make sure it exists.`
+    );
+  }
 };

package/lib/core/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,11 @@ const toDetailedDeclaration = declaration => {
   let detailedDeclaration = pick(['enabled'], declaration);
   if (has('resolve', declaration)) {
     let pathToPlugin = '';
+
     try {
       pathToPlugin = dirname(require.resolve(declaration.resolve));
     } catch (e) {
-      pathToPlugin = resolve(strapi.dirs.root, declaration.resolve);
+      pathToPlugin = resolve(strapi.dirs.app.root, declaration.resolve);
 
       if (!existsSync(pathToPlugin) || !statSync(pathToPlugin).isDirectory()) {
         throw new Error(`${declaration.resolve} couldn't be resolved`);
@@ -71,7 +72,10 @@ const getEnabledPlugins = async strapi => {
       validatePluginName(packageInfo.strapi.name);
       installedPlugins[packageInfo.strapi.name] = {
         ...toDetailedDeclaration({ enabled: true, resolve: packagePath }),
-        info: packageInfo.strapi,
+        info: {
+          ...packageInfo.strapi,
+          packageName: packageInfo.name,
+        },
       };
     }
   }

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