@strapi/strapi 4.2.0-beta.4 → 4.2.2

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

@@ -0,0 +1,100 @@
+'use strict';
+
+const { resolve } = require('path');
+const fse = require('fs-extra');
+const chalk = require('chalk');
+const fetch = require('node-fetch');
+const { v4: uuidv4 } = require('uuid');
+const machineID = require('../utils/machine-id');
+
+const readPackageJSON = async path => {
+  try {
+    const packageObj = await fse.readJson(path);
+    return 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}`);
+    console.log(
+      `${chalk.yellow(
+        'Warning'
+      )}: There has been an error, please set "telemetryDisabled": false in the "strapi" object of your package.json manually.`
+    );
+    return false;
+  }
+};
+
+const generateNewPackageJSON = packageObj => {
+  if (!packageObj.strapi) {
+    return {
+      ...packageObj,
+      strapi: {
+        uuid: uuidv4(),
+        telemetryDisabled: false,
+      },
+    };
+  } else {
+    return {
+      ...packageObj,
+      strapi: {
+        ...packageObj.strapi,
+        uuid: packageObj.strapi.uuid ? packageObj.strapi.uuid : uuidv4(),
+        telemetryDisabled: false,
+      },
+    };
+  }
+};
+
+const sendEvent = async uuid => {
+  try {
+    await fetch('https://analytics.strapi.io/track', {
+      method: 'POST',
+      body: JSON.stringify({
+        event: 'didOptInTelemetry',
+        uuid,
+        deviceId: machineID(),
+      }),
+      headers: { 'Content-Type': 'application/json' },
+    });
+  } catch (e) {
+    //...
+  }
+};
+
+module.exports = async function optInTelemetry() {
+  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 packageObj = await readPackageJSON(packageJSONPath);
+
+  if (packageObj.strapi && packageObj.strapi.uuid) {
+    if (packageObj.strapi.telemetryDisabled === false) {
+      console.log(`${chalk.yellow('Warning:')} telemetry is already enabled`);
+      process.exit(0);
+    }
+  }
+
+  const updatedPackageJSON = generateNewPackageJSON(packageObj);
+
+  const write = await writePackageJSON(packageJSONPath, updatedPackageJSON, 2);
+
+  if (!write) {
+    process.exit(0);
+  }
+
+  await sendEvent(updatedPackageJSON.strapi.uuid);
+  console.log(`${chalk.green('Successfully opted into and enabled Strapi telemetry')}`);
+  process.exit(0);
+};

package/lib/commands/routes/list.js

@@ -3,25 +3,11 @@
 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 appDir = process.cwd();
-
-  const isTSProject = await tsUtils.isUsingTypeScript(appDir);
-  const outDir = await tsUtils.resolveOutDir(appDir);
-
-  if (isTSProject)
-    await tsUtils.compile(appDir, {
-      watch: false,
-      configOptions: { options: { incremental: true } },
-    });
-
-  const distDir = isTSProject ? outDir : appDir;
-
-  const app = await strapi({ appDir, distDir }).load();
+  const app = await strapi().load();
 
   const list = app.server.listRoutes();
 

package/lib/commands/start.js

@@ -1,18 +1,8 @@
 'use strict';
-const fs = require('fs');
-const tsUtils = require('@strapi/typescript-utils');
+
 const strapi = require('../index');
 
 /**
  * `$ strapi start`
  */
-module.exports = async specifiedDir => {
-  const appDir = process.cwd();
-  const isTSProject = await tsUtils.isUsingTypeScript(appDir);
-  const outDir = await tsUtils.resolveOutDir(appDir);
-  const buildDirExists = fs.existsSync(outDir);
-  if (isTSProject && !buildDirExists) throw new Error(`${outDir} directory not found. Please run the build command before starting your application`);
-  const distDir = isTSProject && !specifiedDir ? outDir : specifiedDir;
-
-  strapi({ distDir }).start();
-};
+module.exports = () => strapi().start();

package/lib/commands/watchAdmin.js

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

package/lib/core/app-configuration/config-loader.js

@@ -4,12 +4,14 @@ const path = require('path');
 const fs = require('fs');
 const loadFile = require('./load-config-file');
 
+const VALID_EXTENSIONS = ['.js', '.json'];
+
 module.exports = dir => {
   if (!fs.existsSync(dir)) return {};
 
   return fs
     .readdirSync(dir, { withFileTypes: true })
-    .filter(file => file.isFile())
+    .filter(file => file.isFile() && VALID_EXTENSIONS.includes(path.extname(file.name)))
     .reduce((acc, file) => {
       const key = path.basename(file.name, path.extname(file.name));
 

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

@@ -31,13 +31,12 @@ const defaultConfig = {
   },
 };
 
-module.exports = (dirs, initialConfig = {}) => {
-  const { appDir, distDir } = dirs;
+module.exports = (dir, initialConfig = {}) => {
   const { autoReload = false, serveAdminPanel = true } = initialConfig;
 
-  const pkgJSON = require(path.resolve(appDir, 'package.json'));
+  const pkgJSON = require(path.resolve(dir, 'package.json'));
 
-  const configDir = path.resolve(distDir || process.cwd(), 'config');
+  const configDir = path.resolve(dir || process.cwd(), 'config');
 
   const rootConfig = {
     launchedAt: Date.now(),

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

@@ -4,11 +4,9 @@ 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 = __importDefault(require(file)).default;
+    const jsModule = require(file);
 
     // call if function
     if (typeof jsModule === 'function') {

package/lib/core/bootstrap.js

@@ -25,9 +25,9 @@ module.exports = async function({ strapi }) {
   }
 
   // ensure public repository exists
-  if (!(await fse.pathExists(strapi.dirs.static.public))) {
+  if (!(await fse.pathExists(strapi.dirs.public))) {
     throw new Error(
-      `The public folder (${strapi.dirs.static.public}) doesn't exist or is not accessible. Please make sure it exists.`
+      `The public folder (${strapi.dirs.public}) doesn't exist or is not accessible. Please make sure it exists.`
     );
   }
 };

package/lib/core/loaders/apis.js

@@ -5,7 +5,6 @@ const { existsSync } = require('fs-extra');
 const _ = require('lodash');
 const fse = require('fs-extra');
 const { isKebabCase } = require('@strapi/utils');
-const { importDefault } = require('../../utils');
 
 const DEFAULT_CONTENT_TYPE = {
   schema: {},
@@ -20,11 +19,11 @@ const isDirectory = fd => fd.isDirectory();
 const isDotFile = fd => fd.name.startsWith('.');
 
 module.exports = async strapi => {
-  if (!existsSync(strapi.dirs.dist.api)) {
-    return;
+  if (!existsSync(strapi.dirs.api)) {
+    throw new Error('Missing api folder. Please create one at `./src/api`');
   }
 
-  const apisFDs = await (await fse.readdir(strapi.dirs.dist.api, { withFileTypes: true }))
+  const apisFDs = await (await fse.readdir(strapi.dirs.api, { withFileTypes: true }))
     .filter(isDirectory)
     .filter(_.negate(isDotFile));
 
@@ -33,7 +32,7 @@ module.exports = async strapi => {
   // only load folders
   for (const apiFD of apisFDs) {
     const apiName = normalizeName(apiFD.name);
-    const api = await loadAPI(join(strapi.dirs.dist.api, apiFD.name));
+    const api = await loadAPI(join(strapi.dirs.api, apiFD.name));
 
     apis[apiName] = api;
   }
@@ -155,7 +154,7 @@ const loadFile = file => {
 
   switch (ext) {
     case '.js':
-      return importDefault(require(file)).default;
+      return require(file);
     case '.json':
       return fse.readJSON(file);
     default:

package/lib/core/loaders/components.js

@@ -6,20 +6,19 @@ const { pathExists } = require('fs-extra');
 const loadFiles = require('../../load/load-files');
 
 module.exports = async strapi => {
-  if (!(await pathExists(strapi.dirs.dist.components))) {
+  if (!(await pathExists(strapi.dirs.components))) {
     return {};
   }
 
-  const map = await loadFiles(strapi.dirs.dist.components, '*/*.*(js|json)');
+  const map = await loadFiles(strapi.dirs.components, '*/*.*(js|json)');
 
   return Object.keys(map).reduce((acc, category) => {
     Object.keys(map[category]).forEach(key => {
       const schema = map[category][key];
 
-      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__);
+      const filePath = join(strapi.dirs.components, category, schema.__filename__);
 
+      if (!schema.collectionName) {
         return strapi.stopWithError(
           `Component ${key} is missing a "collectionName" property.\nVerify file ${filePath}.`
         );

package/lib/core/loaders/middlewares.js

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

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

@@ -29,11 +29,10 @@ 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.app.root, declaration.resolve);
+      pathToPlugin = resolve(strapi.dirs.root, declaration.resolve);
 
       if (!existsSync(pathToPlugin) || !statSync(pathToPlugin).isDirectory()) {
         throw new Error(`${declaration.resolve} couldn't be resolved`);

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.dist.config, 'plugins.js');
+  const globalUserConfigPath = join(strapi.dirs.config, 'plugins.js');
   const currentEnvUserConfigPath = join(
-    strapi.dirs.dist.config,
+    strapi.dirs.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.dist.extensions;
+  const extensionsDir = strapi.dirs.extensions;
   if (!(await fse.pathExists(extensionsDir))) {
     return;
   }

package/lib/core/loaders/policies.js

@@ -3,11 +3,9 @@
 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.dist.policies;
+  const dir = strapi.dirs.policies;
 
   if (!(await fse.pathExists(dir))) {
     return;
@@ -22,7 +20,7 @@ module.exports = async function loadPolicies(strapi) {
 
     if (fd.isFile() && extname(name) === '.js') {
       const key = basename(name, '.js');
-      policies[key] = importDefault(require(fullPath)).default;
+      policies[key] = require(fullPath);
     }
   }
 

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

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

package/lib/core/registries/policies.d.ts

@@ -6,4 +6,4 @@ interface PolicyContext extends BaseContext {
   is(name): boolean;
 }
 
-export type Policy<T=unknown> = (ctx: PolicyContext,cfg:T, { strapi: Strapi }) => boolean | undefined;
+export type Policy = (ctx: PolicyContext, { strapi: Strapi }) => boolean | undefined;

package/lib/core-api/controller/index.d.ts

@@ -1,6 +1,6 @@
 import { Context } from 'koa';
 
-type ControllerResponse <T=unknown> = T | Promise<T>;
+type Response = object;
 
 interface BaseController {
   transformResponse(data: object, meta: object): object;
@@ -9,22 +9,17 @@ interface BaseController {
 }
 
 export interface SingleTypeController extends BaseController {
-  find(ctx: Context): ControllerResponse;
-  update(ctx: Context): ControllerResponse;
-  delete(ctx: Context): ControllerResponse;
+  find(ctx: Context): Promise<Response>;
+  update(ctx: Context): Promise<Response>;
+  delete(ctx: Context): Promise<Response>;
 }
 
 export interface CollectionTypeController extends BaseController {
-  find(ctx: Context): ControllerResponse;
-  findOne(ctx: Context): ControllerResponse
-  create(ctx: Context): ControllerResponse;
-  update(ctx: Context): ControllerResponse;
-  delete(ctx: Context): ControllerResponse;
+  find(ctx: Context): Promise<Response>;
+  findOne(ctx: Context): Promise<Response>;
+  create(ctx: Context): Promise<Response>;
+  update(ctx: Context): Promise<Response>;
+  delete(ctx: Context): Promise<Response>;
 }
 
 export type Controller = SingleTypeController | CollectionTypeController;
-
-export type GenericController = Partial<Controller> & {
-  [method: string | number | symbol]: (ctx: Context) => unknown
-}
-​

package/lib/core-api/service/index.d.ts

@@ -1,22 +1,21 @@
 type Entity = object;
 
 interface BaseService {
-  getFetchParams?(params: object): object;
+  getFetchParams(params: object): object;
 }
 
 export interface SingleTypeService extends BaseService {
-  find?(params: object): Promise<Entity> | Entity;
-  createOrUpdate?(params: object): Promise<Entity> | Entity;
-  delete?(params: object): Promise<Entity> | Entity;
+  find(params: object): Promise<Entity>;
+  createOrUpdate(params: object): Promise<Entity>;
+  delete(params: object): Promise<Entity>;
 }
 
 export interface CollectionTypeService extends BaseService {
-  find?(params: object): Promise<Entity[]> | Entity;
-  findOne?(entityId: string,params: object): Promise<Entity> | Entity;
-  create?(params: object): Promise<Entity> | Entity;
-  update?(entityId: string,params: object): Promise<Entity> | Entity;
-  delete?(entityId: string,params: object): Promise<Entity> | Entity;
+  find(params: object): Promise<Entity[]>;
+  findOne(params: object): Promise<Entity>;
+  create(params: object): Promise<Entity>;
+  update(params: object): Promise<Entity>;
+  delete(params: object): Promise<Entity>;
 }
 
 export type Service = SingleTypeService | CollectionTypeService;
-

package/lib/factories.d.ts

@@ -1,37 +1,36 @@
 import { Service } from './core-api/service';
-import { Controller, GenericController } from './core-api/controller';
+import { Controller } from './core-api/controller';
 import { Middleware } from './middlewares';
 import { Policy } from './core/registries/policies';
-import { Strapi } from '@strapi/strapi'
 
-type ControllerConfig<T extends Controller = Controller> = T;
+type ControllerConfig = Controller;
 
 type ServiceConfig = Service;
 
 type HandlerConfig = {
-  auth?: false | { scope: string[] };
-  policies?: Array<string | Policy>;
-  middlewares?: Array<string | Middleware>;
+  auth: false | { scope: string[] };
+  policies: Array<string | Policy>;
+  middlewares: Array<string | Middleware>;
 };
 
 type SingleTypeRouterConfig = {
-  find?: HandlerConfig;
-  update?: HandlerConfig;
-  delete?: HandlerConfig;
+  find: HandlerConfig;
+  update: HandlerConfig;
+  delete: HandlerConfig;
 };
 
 type CollectionTypeRouterConfig = {
-  find?: HandlerConfig;
-  findOne?: HandlerConfig;
-  create?: HandlerConfig;
-  update?: HandlerConfig;
-  delete?: HandlerConfig;
+  find: HandlerConfig;
+  findOne: HandlerConfig;
+  create: HandlerConfig;
+  update: HandlerConfig;
+  delete: HandlerConfig;
 };
 
 type RouterConfig = {
-  prefix?: string;
+  prefix: string;
   only: string[];
-  except?: string[];
+  except: string[];
   config: SingleTypeRouterConfig | CollectionTypeRouterConfig;
 };
 
@@ -44,9 +43,6 @@ interface Router {
   routes: Route[];
 }
 
-type ControllerCallback <T extends GenericController = GenericController> = (params:{strapi:Strapi}) => T;
-type ServiceCallback <T extends Service = Sevice> = (params:{strapi:Strapi}) => T
-
-export function createCoreRouter(uid: string, cfg?: RouterConfig = {}): () => Router;
-export function createCoreController<T extends GenericController = GenericController>(uid: string, cfg?: ControllerCallback<T> | T = {}): () => T & Controller;
-export function createCoreService<T extends Service = Service>(uid: string, cfg?: ServiceCallback<T> | T = {}): () => T ;
+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/index.d.ts

@@ -1,15 +1,14 @@
 import { Database } from '@strapi/database';
 import { EntityService } from './services/entity-service';
+import { Strapi as StrapiClass } from './Strapi';
 
-import * as Core from './types/strapi';
 export * as factories from './factories';
+interface StrapiInterface extends StrapiClass {
+  query: Database['query'];
+  entityService: EntityService;
+}
 
-export type { Core };
-
-// Alias to resolve the Strapi global type easily
-export type Strapi = Core.Strapi;
-
-export interface StrapiInterface extends Core.Strapi {};
+export type Strapi = StrapiInterface;
 
 declare global {
   interface AllTypes {}

package/lib/load/load-files.js

@@ -3,8 +3,6 @@
 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');
 
@@ -36,7 +34,7 @@ const loadFiles = async (
     if (path.extname(absolutePath) === '.json') {
       mod = await fse.readJson(absolutePath);
     } else {
-      mod = importDefault(requireFn(absolutePath)).default;
+      mod = requireFn(absolutePath);
     }
 
     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.app.root, faviconPath), { maxAge });
+  return favicon(resolve(strapi.dirs.root, faviconPath), { maxAge });
 };

package/lib/middlewares/public/index.js

@@ -71,7 +71,6 @@ 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,
@@ -81,7 +80,7 @@ module.exports = (config, { strapi }) => {
       {
         method: 'GET',
         path: '/(.*)',
-        handler: koaStatic(strapi.dirs.static.public, {
+        handler: koaStatic(strapi.dirs.public, {
           maxage: maxAge,
           defer: true,
         }),