@strapi/strapi 4.2.0-beta.1 → 4.2.0-beta.4

package/bin/strapi.js

@@ -95,6 +95,7 @@ program
   .option('--dbssl <dbssl>', 'Database SSL')
   .option('--dbfile <dbfile>', 'Database file path for sqlite')
   .option('--dbforce', 'Allow overwriting existing database content')
+  .option('-ts, --typescript', 'Create a typescript project')
   .description('Create a new application')
   .action(require('../lib/commands/new'));
 

package/lib/Strapi.js

@@ -38,10 +38,15 @@ const apisRegistry = require('./core/registries/apis');
 const bootstrap = require('./core/bootstrap');
 const loaders = require('./core/loaders');
 const { destroyOnSignal } = require('./utils/signals');
+const sanitizersRegistry = require('./core/registries/sanitizers');
 
 // TODO: move somewhere else
 const draftAndPublishSync = require('./migrations/draft-publish');
 
+/**
+ * A map of all the available Strapi lifecycles
+ * @type {import('@strapi/strapi').Core.Lifecycles}
+ */
 const LIFECYCLES = {
   REGISTER: 'register',
   BOOTSTRAP: 'bootstrap',
@@ -68,6 +73,7 @@ const resolveWorkingDirectories = opts => {
   return { app: appDir, dist: distDir };
 };
 
+/** @implements {import('@strapi/strapi').Strapi} */
 class Strapi {
   constructor(opts = {}) {
     destroyOnSignal(this);
@@ -92,6 +98,7 @@ class Strapi {
     this.container.register('plugins', pluginsRegistry(this));
     this.container.register('apis', apisRegistry(this));
     this.container.register('auth', createAuth(this));
+    this.container.register('sanitizers', sanitizersRegistry(this));
 
     // Create a mapping of every useful directory (for the app, dist and static directories)
     this.dirs = utils.getDirs(rootDirs, { strapi: this });
@@ -190,6 +197,10 @@ class Strapi {
     return this.container.get('auth');
   }
 
+  get sanitizers() {
+    return this.container.get('sanitizers');
+  }
+
   async start() {
     try {
       if (!this.isLoaded) {
@@ -337,6 +348,10 @@ class Strapi {
     this.app = await loaders.loadSrcIndex(this);
   }
 
+  async loadSanitizers() {
+    await loaders.loadSanitizers(this);
+  }
+
   registerInternalHooks() {
     this.container.get('hooks').set('strapi::content-types.beforeSync', createAsyncParallelHook());
     this.container.get('hooks').set('strapi::content-types.afterSync', createAsyncParallelHook());
@@ -348,6 +363,7 @@ class Strapi {
   async register() {
     await Promise.all([
       this.loadApp(),
+      this.loadSanitizers(),
       this.loadPlugins(),
       this.loadAdmin(),
       this.loadAPIs(),

package/lib/commands/admin-create.js

@@ -3,6 +3,7 @@
 const { yup } = require('@strapi/utils');
 const _ = require('lodash');
 const inquirer = require('inquirer');
+const tsUtils = require('@strapi/typescript-utils');
 const strapi = require('../index');
 
 const emailValidator = yup
@@ -90,7 +91,20 @@ module.exports = async function(cmdOptions = {}) {
 };
 
 async function createAdmin({ email, password, firstname, lastname }) {
-  const app = await strapi().load();
+  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 user = await app.admin.services.user.exists({ email });
 

package/lib/commands/admin-reset.js

@@ -2,6 +2,7 @@
 
 const _ = require('lodash');
 const inquirer = require('inquirer');
+const tsUtils = require('@strapi/typescript-utils');
 const strapi = require('../index');
 
 const promptQuestions = [
@@ -42,7 +43,20 @@ module.exports = async function(cmdOptions = {}) {
 };
 
 async function changePassword({ email, password }) {
-  const app = await strapi().load();
+  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();
 
   await app.admin.services.user.resetPasswordByEmail(email, password);
 

package/lib/commands/build.js

@@ -1,5 +1,4 @@
 'use strict';
-const path = require('path');
 
 const tsUtils = require('@strapi/typescript-utils');
 const { buildAdmin, buildTypeScript } = require('./builders');
@@ -12,13 +11,14 @@ module.exports = async ({ optimization, forceBuild = true }) => {
   const srcDir = process.cwd();
 
   const useTypeScriptServer = await tsUtils.isUsingTypeScript(srcDir);
+  const outDir = await tsUtils.resolveOutDir(srcDir);
 
   // Typescript
   if (useTypeScriptServer) {
     await buildTypeScript({ srcDir, watch: false });
 
     // Update the dir path for the next steps
-    buildDestDir = path.join(srcDir, 'dist');
+    buildDestDir = outDir;
   }
 
   await buildAdmin({

package/lib/commands/configurationDump.js

@@ -1,6 +1,7 @@
 'use strict';
 
 const fs = require('fs');
+const tsUtils = require('@strapi/typescript-utils');
 const strapi = require('../index');
 
 const CHUNK_SIZE = 100;
@@ -12,7 +13,19 @@ const CHUNK_SIZE = 100;
 module.exports = async function({ file: filePath, pretty }) {
   const output = filePath ? fs.createWriteStream(filePath) : process.stdout;
 
-  const app = await strapi().load();
+  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 count = await app.query('strapi::core-store').count();
 

package/lib/commands/configurationRestore.js

@@ -2,6 +2,8 @@
 
 const fs = require('fs');
 const _ = require('lodash');
+const tsUtils = require('@strapi/typescript-utils');
+
 const strapi = require('../index');
 
 /**
@@ -12,7 +14,20 @@ const strapi = require('../index');
 module.exports = async function({ file: filePath, strategy = 'replace' }) {
   const input = filePath ? fs.readFileSync(filePath) : await readStdin(process.stdin);
 
-  const app = await strapi().load();
+  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();
 
   let dataToImport;
   try {

package/lib/commands/console.js

@@ -1,14 +1,28 @@
 'use strict';
 
 const REPL = require('repl');
+const tsUtils = require('@strapi/typescript-utils');
+
 const strapi = require('../index');
 
 /**
  * `$ strapi console`
  */
-module.exports = () => {
+module.exports = async () => {
   // Now load up the Strapi framework for real.
-  const app = strapi();
+  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();
 
   app.start().then(() => {
     const repl = REPL.start(app.config.info.name + ' > ' || 'strapi > '); // eslint-disable-line prefer-template

package/lib/commands/develop.js

@@ -22,7 +22,8 @@ module.exports = async function({ build, watchAdmin, polling, browser }) {
   const appDir = process.cwd();
 
   const isTSProject = await tsUtils.isUsingTypeScript(appDir);
-  const distDir = isTSProject ? path.join(appDir, 'dist') : appDir;
+  const outDir = await tsUtils.resolveOutDir(appDir);
+  const distDir = isTSProject ? outDir : appDir;
 
   try {
     if (cluster.isMaster || cluster.isPrimary) {

package/lib/commands/routes/list.js

@@ -3,11 +3,25 @@
 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 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 list = app.server.listRoutes();
 

package/lib/commands/start.js

@@ -1,8 +1,18 @@
 'use strict';
-
+const fs = require('fs');
+const tsUtils = require('@strapi/typescript-utils');
 const strapi = require('../index');
 
 /**
  * `$ strapi start`
  */
-module.exports = distDir => strapi({ distDir }).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();
+};

package/lib/commands/watchAdmin.js

@@ -1,6 +1,5 @@
 'use strict';
 
-const path = require('path');
 const strapiAdmin = require('@strapi/admin');
 const tsUtils = require('@strapi/typescript-utils');
 const { getConfigUrls, getAbsoluteServerUrl } = require('@strapi/utils');
@@ -13,7 +12,8 @@ module.exports = async function({ browser }) {
   const currentDirectory = process.cwd();
 
   const isTSProject = await tsUtils.isUsingTypeScript(currentDirectory);
-  const buildDestDir = isTSProject ? path.join(currentDirectory, 'dist') : currentDirectory;
+  const outDir = await tsUtils.resolveOutDir(currentDirectory);
+  const buildDestDir = isTSProject ? outDir : currentDirectory;
 
   const strapiInstance = strapi({
     distDir: buildDestDir,

package/lib/core/loaders/apis.js

@@ -7,31 +7,35 @@ 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));
-
 const DEFAULT_CONTENT_TYPE = {
   schema: {},
   actions: {},
   lifecycles: {},
 };
 
+// to handle names with numbers in it we first check if it is already in kebabCase
+const normalizeName = name => (isKebabCase(name) ? name : _.kebabCase(name));
+
+const isDirectory = fd => fd.isDirectory();
+const isDotFile = fd => fd.name.startsWith('.');
+
 module.exports = async strapi => {
   if (!existsSync(strapi.dirs.dist.api)) {
     return;
   }
 
-  const apisFDs = await fse.readdir(strapi.dirs.dist.api, { withFileTypes: true });
+  const apisFDs = await (await fse.readdir(strapi.dirs.dist.api, { withFileTypes: true }))
+    .filter(isDirectory)
+    .filter(_.negate(isDotFile));
+
   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.dist.api, apiFD.name));
+    const apiName = normalizeName(apiFD.name);
+    const api = await loadAPI(join(strapi.dirs.dist.api, apiFD.name));
 
-      apis[apiName] = api;
-    }
+    apis[apiName] = api;
   }
 
   validateContentTypesUnicity(apis);

package/lib/core/loaders/index.js

@@ -8,4 +8,5 @@ module.exports = {
   loadPolicies: require('./policies'),
   loadPlugins: require('./plugins'),
   loadAdmin: require('./admin'),
+  loadSanitizers: require('./sanitizers'),
 };

package/lib/core/loaders/sanitizers.js

@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = strapi => {
+  strapi.container.get('sanitizers').set('content-api', { input: [], output: [] });
+};

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

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

package/lib/core/registries/sanitizers.js

@@ -0,0 +1,26 @@
+'use strict';
+
+const _ = require('lodash');
+
+const sanitizersRegistry = () => {
+  const sanitizers = {};
+
+  return {
+    get(path) {
+      return _.get(sanitizers, path, []);
+    },
+    add(path, sanitizer) {
+      this.get(path).push(sanitizer);
+      return this;
+    },
+    set(path, value = []) {
+      _.set(sanitizers, path, value);
+      return this;
+    },
+    has(path) {
+      return _.has(sanitizers, path);
+    },
+  };
+};
+
+module.exports = sanitizersRegistry;

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

@@ -1,6 +1,6 @@
 import { Context } from 'koa';
 
-type Response = object;
+type ControllerResponse <T=unknown> = T | Promise<T>;
 
 interface BaseController {
   transformResponse(data: object, meta: object): object;
@@ -9,17 +9,22 @@ interface BaseController {
 }
 
 export interface SingleTypeController extends BaseController {
-  find(ctx: Context): Promise<Response>;
-  update(ctx: Context): Promise<Response>;
-  delete(ctx: Context): Promise<Response>;
+  find(ctx: Context): ControllerResponse;
+  update(ctx: Context): ControllerResponse;
+  delete(ctx: Context): ControllerResponse;
 }
 
 export interface CollectionTypeController extends BaseController {
-  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>;
+  find(ctx: Context): ControllerResponse;
+  findOne(ctx: Context): ControllerResponse
+  create(ctx: Context): ControllerResponse;
+  update(ctx: Context): ControllerResponse;
+  delete(ctx: Context): ControllerResponse;
 }
 
 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,21 +1,22 @@
 type Entity = object;
 
 interface BaseService {
-  getFetchParams(params: object): object;
+  getFetchParams?(params: object): object;
 }
 
 export interface SingleTypeService extends BaseService {
-  find(params: object): Promise<Entity>;
-  createOrUpdate(params: object): Promise<Entity>;
-  delete(params: object): Promise<Entity>;
+  find?(params: object): Promise<Entity> | Entity;
+  createOrUpdate?(params: object): Promise<Entity> | Entity;
+  delete?(params: object): Promise<Entity> | Entity;
 }
 
 export interface CollectionTypeService extends BaseService {
-  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>;
+  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;
 }
 
 export type Service = SingleTypeService | CollectionTypeService;
+

package/lib/factories.d.ts

@@ -1,36 +1,37 @@
 import { Service } from './core-api/service';
-import { Controller } from './core-api/controller';
+import { Controller, GenericController } from './core-api/controller';
 import { Middleware } from './middlewares';
 import { Policy } from './core/registries/policies';
+import { Strapi } from '@strapi/strapi'
 
-type ControllerConfig = Controller;
+type ControllerConfig<T extends Controller = Controller> = T;
 
 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;
 };
 
@@ -43,6 +44,9 @@ 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(uid: string, cfg?: ControllerConfig = {}): () => Controller;
-export function createCoreService(uid: string, cfg?: ServiceConfig = {}): () => Service;
+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 ;

package/lib/index.d.ts

@@ -1,14 +1,15 @@
 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';
-export interface StrapiInterface extends StrapiClass {
-  query: Database['query'];
-  entityService: EntityService;
-}
 
-export type Strapi = StrapiInterface;
+export type { Core };
+
+// Alias to resolve the Strapi global type easily
+export type Strapi = Core.Strapi;
+
+export interface StrapiInterface extends Core.Strapi {};
 
 declare global {
   interface AllTypes {}

package/lib/middlewares/body.js

@@ -3,12 +3,23 @@
 const fse = require('fs-extra');
 const { defaultsDeep, get } = require('lodash/fp');
 const body = require('koa-body');
+const mime = require('mime-types');
 
 const defaults = {
   multipart: true,
   patchKoa: true,
 };
 
+function ensureFileMimeType(file) {
+  if (!file.type) {
+    file.type = mime.lookup(file.name) || 'application/octet-stream';
+  }
+}
+
+function getFiles(ctx) {
+  return get('request.files.files', ctx);
+}
+
 /**
  * @type {import('./').MiddlewareFactory}
  */
@@ -18,21 +29,38 @@ module.exports = config => {
   return async (ctx, next) => {
     // TODO: find a better way later
     if (ctx.url === '/graphql') {
-      return next();
-    }
+      await next();
+    } else {
+      try {
+        await body({ patchKoa: true, ...bodyConfig })(ctx, () => {});
 
-    try {
-      await body({ patchKoa: true, ...bodyConfig })(ctx, next);
-    } catch (e) {
-      if ((e || {}).message && e.message.includes('maxFileSize exceeded')) {
-        return ctx.payloadTooLarge('FileTooBig');
-      }
+        const files = getFiles(ctx);
 
-      throw e;
+        /**
+         * in case the mime-type wasn't sent, Strapi tries to guess it
+         * from the file extension, to avoid a corrupt database state
+         */
+        if (files) {
+          if (Array.isArray(files)) {
+            files.forEach(ensureFileMimeType);
+          } else {
+            ensureFileMimeType(files);
+          }
+        }
+
+        await next();
+      } catch (e) {
+        if ((e || {}).message && e.message.includes('maxFileSize exceeded')) {
+          return ctx.payloadTooLarge('FileTooBig');
+        }
+
+        throw e;
+      }
     }
 
+    const files = getFiles(ctx);
+
     // clean any file that was uploaded
-    const files = get('request.files.files', ctx);
     if (files) {
       if (Array.isArray(files)) {
         // not awaiting to not slow the request

package/lib/services/entity-validator/validators.js

@@ -166,7 +166,9 @@ const stringValidator = composeValidators(
   addUniqueValidator
 );
 
-const emailValidator = composeValidators(stringValidator, validator => validator.email());
+const emailValidator = composeValidators(stringValidator, validator =>
+  validator.email().min(1, '${path} cannot be empty')
+);
 
 const uidValidator = composeValidators(stringValidator, validator =>
   validator.matches(new RegExp('^[A-Za-z0-9-_.~]*$'))

package/lib/types/strapi.d.ts

@@ -0,0 +1,291 @@
+import type Koa from 'koa';
+
+import type { StringMap } from './utils';
+
+type Controller = {
+  [methodName: string | number | symbol]: (context: Koa.Context) => unknown;
+}
+
+/**
+ * The Strapi interface implemented by the main Strapi class.
+ */
+export interface Strapi {
+  /**
+   * Getter for the Strapi enterprise edition configuration
+   */
+  readonly EE: any;
+
+  /**
+   * Getter for the Strapi configuration container
+   */
+  readonly config: any;
+
+  /**
+   * Getter for the Strapi auth container
+   */
+  readonly auth: any;
+
+  /**
+   * Getter for the Strapi sanitizers container
+   */
+  readonly sanitizers: any;
+
+  /**
+   * Getter for the Strapi services container
+   *
+   * It returns all the registered services
+   */
+  readonly services: StringMap<Service>;
+
+  /**
+   * Find a service using its unique identifier
+   */
+  service<T extends Service = unknown>(uid: string): T | undefined;
+
+  /**
+   * Getter for the Strapi controllers container
+   *
+   * It returns all the registered controllers
+   */
+  readonly controllers: StringMap<Controller>;
+
+  /**
+   * Find a controller using its unique identifier
+   */
+  controller(uid: string): Controller | undefined;
+
+  /**
+   * Getter for the Strapi content types container
+   *
+   * It returns all the registered content types
+   */
+  readonly contentTypes: any;
+
+  /**
+   * Find a content type using its unique identifier
+   */
+  contentType(uid: string): any;
+
+  /**
+   * Getter for the Strapi policies container
+   *
+   * It returns all the registered policies
+   */
+  readonly policies: any;
+
+  /**
+   * Find a policy using its name
+   */
+  policy(name: string): any;
+
+  /**
+   * Getter for the Strapi middlewares container
+   *
+   * It returns all the registered middlewares
+   */
+  readonly middlewares: any;
+
+  /**
+   * Find a middleware using its name
+   */
+  middleware(): any;
+
+  /**
+   * Getter for the Strapi plugins container
+   *
+   * It returns all the registered plugins
+   */
+  readonly plugins: any;
+
+  /**
+   * Find a plugin using its name
+   */
+  plugin(name: string): any;
+
+  /**
+   * Getter for the Strapi hooks container
+   *
+   * It returns all the registered hooks
+   */
+  readonly hooks: any;
+
+  /**
+   * Find a hook using its name
+   */
+  hook(): any;
+
+  /**
+   * Getter for the Strapi APIs container
+   *
+   * It returns all the registered APIs
+   */
+  readonly api: any;
+
+  /**
+   * Strapi Register Lifecycle.
+   *
+   * - Load
+   *   - The user application
+   *   - The plugins
+   *   - The admin
+   *   - The APIs
+   *   - The components
+   *   - The middlewares
+   *   - The policies
+   * - Trigger Strapi internal bootstrap
+   * - Create the webhooks runner
+   * - Create the internal hooks registry.
+   * - Init the telemetry cron job and middleware
+   * - Run all the `register` lifecycle methods loaded by the user application or the enabled plugins
+   */
+  register(): Promise<Strapi>;
+
+  /**
+   * Bootstraping phase.
+   *
+   * - Load all the content types
+   * - Initialize the database layer
+   * - Initialize the entity service
+   * - Run the schemas/database synchronization
+   * - Start the webhooks and initializing middlewares and routes
+   * - Run all the `bootstrap` lifecycle methods loaded by the
+   * user application or the enabled plugins
+   */
+  bootstrap(): Promise<Strapi>;
+
+  /**
+   * Destroy phase
+   *
+   * - Destroy Strapi server
+   * - Run all the `destroy` lifecycle methods loaded by the
+   * user application or the enabled plugins
+   * - Cleanup the event hub
+   * - Gracefully stop the database
+   * - Stop the telemetry and cron instance
+   * - Cleanup the global scope by removing global.strapi
+   */
+  destroy(): Promise<void>;
+
+  /**
+   * Run all functions registered for a given lifecycle. (Strapi core, user app, plugins)
+   */
+  runLifecyclesFunctions<T extends Lifecycles[keyof Lifecycles]>(lifecycleName: T): Promise<void>;
+
+  /**
+   * Load the application if needed and start the server
+   */
+  start(): Promise<void>;
+
+  /**
+   * Stop the server and provide a custom error and message
+   */
+  stopWithError<TError = unknown>(error: TError, customMessage?: string): void;
+
+  /**
+   * Gracefully stop the server
+   * Call the destroy method.
+   */
+  stop(code?: number): void;
+
+  /**
+   * Load the server and the user application.
+   * It basically triggers the register and bootstrap phases
+   */
+  load(): Promise<Strapi>;
+
+  /**
+   * Restart the server and reload all the configuration.
+   * It re-runs all the lifecycles phases.
+   * 
+   * @example
+   * ``` ts
+   * setImmediate(() => strapi.reload());
+   * ```
+   */
+  reload(): () => void;
+
+  /**
+   * Initialize and start all the webhooks registered in the webhook store
+   */
+  startWebhooks(): Promise<void>;
+
+  /**
+   * Method called when the server is fully initialized and listen to incomming requests.
+   * It handles tasks such as logging the startup message
+   * or automatically opening the administration panel.
+   */
+  postListen(): Promise<void>;
+
+  /**
+   * Start listening for incomming requests
+   */
+  listen(): Promise<void | Error>;
+
+  /**
+   * Opent he administration panel in a browser if the option is enabled.
+   * You can disable it using the admin.autoOpen configuration variable.
+   * 
+   * Note: It only works in development envs.
+   */
+  openAdmin(options: { isInitialized: boolean }): Promise<void>;
+
+  /**
+   * Load the admin panel server logic into the server code and initialize its configuration. 
+   */
+  loadAdmin(): Promise<void>;
+
+  /**
+   * Resolve every enabled plugin and load them into the application.
+   */
+  loadPlugins(): Promise<void>;
+
+  /**
+   * Load every global policies in the policies container by
+   * reading from the `strapi.dirs.dist.policies` directory.
+   */
+  loadPolicies(): Promise<void>;
+
+  /**
+   * Load every APIs and their components (config, routes, controllers, services,
+   * policies, middlewares, content-types) in the API container.
+   */
+  loadAPIs(): Promise<void>;
+
+  /**
+   * Resolve every components in the user application and store them in `strapi.components`
+   */
+  loadComponents(): Promise<void>;
+
+  /**
+   * Load every global and core middlewares in the middlewares container by
+   * reading from the `strapi.dirs.dist.middlewares` and internal middlewares directory.
+   */
+  loadMiddlewares(): Promise<void>;
+
+  /**
+   * Load the user application in the server by reading the `src/index.js` file.
+   */
+  loadApp(): Promise<void>;
+
+  /**
+   * Add internal hooks to the hooks container.
+   * Those hooks are meant for internal usage and might break in future releases.
+   */
+  registerInternalHooks(): void;
+
+  /**
+   * Find a model (content-type, component) based on its unique identifier.
+   */
+  getModel(uid: string): any;
+
+  /**
+   * Binds database queries for a specific model based on its unique identifier.
+   */
+  query(uid: string): any;
+}
+
+export interface Lifecycles {
+  REGISTER: 'register';
+  BOOTSTRAP: 'bootstrap';
+  DESTROY: 'destroy';
+}

package/lib/types/utils.d.ts

@@ -0,0 +1 @@
+export type StringMap<T> = { [key: string]: T };

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

@@ -20,7 +20,7 @@ const boxenOptions = {
   borderStyle: 'round',
 };
 
-const geUpdatetMessage = (newVersion, currentVersion) => {
+const getUpdateMessage = (newVersion, currentVersion) => {
   const currentVersionLog = chalk.dim(currentVersion);
   const newVersionLog = chalk.green(newVersion);
   const releaseLink = chalk.bold('https://github.com/strapi/strapi/releases');
@@ -78,7 +78,7 @@ const createUpdateNotifier = strapi => {
       return;
     }
 
-    const message = boxen(geUpdatetMessage(latestVersion, pkg.version), boxenOptions);
+    const message = boxen(getUpdateMessage(latestVersion, pkg.version), boxenOptions);
     config.set('lastNotification', now);
     console.log(message);
   };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strapi/strapi",
-  "version": "4.2.0-beta.1",
+  "version": "4.2.0-beta.4",
   "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,17 @@
   "dependencies": {
     "@koa/cors": "3.1.0",
     "@koa/router": "10.1.1",
-    "@strapi/admin": "4.2.0-beta.1",
-    "@strapi/database": "4.2.0-beta.1",
-    "@strapi/generate-new": "4.2.0-beta.1",
-    "@strapi/generators": "4.2.0-beta.1",
-    "@strapi/logger": "4.2.0-beta.1",
-    "@strapi/plugin-content-manager": "4.2.0-beta.1",
-    "@strapi/plugin-content-type-builder": "4.2.0-beta.1",
-    "@strapi/plugin-email": "4.2.0-beta.1",
-    "@strapi/plugin-upload": "4.2.0-beta.1",
-    "@strapi/typescript-utils": "4.2.0-beta.1",
-    "@strapi/utils": "4.2.0-beta.1",
+    "@strapi/admin": "4.2.0-beta.4",
+    "@strapi/database": "4.2.0-beta.4",
+    "@strapi/generate-new": "4.2.0-beta.4",
+    "@strapi/generators": "4.2.0-beta.4",
+    "@strapi/logger": "4.2.0-beta.4",
+    "@strapi/plugin-content-manager": "4.2.0-beta.4",
+    "@strapi/plugin-content-type-builder": "4.2.0-beta.4",
+    "@strapi/plugin-email": "4.2.0-beta.4",
+    "@strapi/plugin-upload": "4.2.0-beta.4",
+    "@strapi/typescript-utils": "4.2.0-beta.4",
+    "@strapi/utils": "4.2.0-beta.4",
     "bcryptjs": "2.4.3",
     "boxen": "5.1.2",
     "chalk": "4.1.2",
@@ -118,6 +118,7 @@
     "koa-session": "6.2.0",
     "koa-static": "5.0.0",
     "lodash": "4.17.21",
+    "mime-types": "2.1.35",
     "node-fetch": "2.6.7",
     "node-machine-id": "1.1.12",
     "node-schedule": "2.0.0",
@@ -135,8 +136,8 @@
     "typescript": "4.6.2"
   },
   "engines": {
-    "node": ">=12.22.0 <=16.x.x",
+    "node": ">=14.19.1 <=16.x.x",
     "npm": ">=6.0.0"
   },
-  "gitHead": "4fa2804f35e15ed72dfd309fb5bb1c4dba18932f"
+  "gitHead": "5caff35a30e33b7a660eb946299f9e3d2d35b2b8"
 }