@strapi/strapi 4.2.0-beta.0 → 4.2.0-beta.3

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

@@ -29,15 +29,11 @@ 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) {
-      // 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);
+      pathToPlugin = resolve(strapi.dirs.app.root, declaration.resolve);
 
       if (!existsSync(pathToPlugin) || !statSync(pathToPlugin).isDirectory()) {
         throw new Error(`${declaration.resolve} couldn't be resolved`);
@@ -45,7 +41,6 @@ const toDetailedDeclaration = declaration => {
     }
 
     detailedDeclaration.pathToPlugin = pathToPlugin;
-    detailedDeclaration.appPathToPlugin = appPathToPlugin;
   }
   return detailedDeclaration;
 };

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';
-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/middlewares/public/index.js

@@ -81,7 +81,7 @@ module.exports = (config, { strapi }) => {
       {
         method: 'GET',
         path: '/(.*)',
-        handler: koaStatic(strapi.dirs.app.public, {
+        handler: koaStatic(strapi.dirs.static.public, {
           maxage: maxAge,
           defer: true,
         }),

package/lib/middlewares/session.js

@@ -19,7 +19,9 @@ const defaultConfig = {
 module.exports = (userConfig, { strapi }) => {
   const keys = strapi.server.app.keys;
   if (!isArray(keys) || isEmpty(keys) || keys.some(isEmpty)) {
-    throw new Error(`App keys are required. Please set app.keys in config/server.js (ex: keys: ['myKeyA', 'myKeyB'])`);
+    throw new Error(
+      `App keys are required. Please set app.keys in config/server.js (ex: keys: ['myKeyA', 'myKeyB'])`
+    );
   }
 
   const config = defaultsDeep(defaultConfig, userConfig);

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/services/metrics/index.js

@@ -24,13 +24,19 @@ const LIMITED_EVENTS = [
 
 const createTelemetryInstance = strapi => {
   const uuid = strapi.config.get('uuid');
-  const isDisabled = !uuid || isTruthy(process.env.STRAPI_TELEMETRY_DISABLED);
+  const telemetryDisabled = strapi.config.get('packageJsonStrapi.telemetryDisabled');
+  const isDisabled =
+    !uuid || isTruthy(process.env.STRAPI_TELEMETRY_DISABLED) || isTruthy(telemetryDisabled);
 
   const crons = [];
   const sender = createSender(strapi);
   const sendEvent = wrapWithRateLimit(sender, { limitedEvents: LIMITED_EVENTS });
 
   return {
+    get isDisabled() {
+      return isDisabled;
+    },
+
     register() {
       if (!isDisabled) {
         const pingCron = scheduleJob('0 0 12 * * *', () => sendEvent('ping'));

package/lib/services/metrics/sender.js

@@ -1,10 +1,12 @@
 'use strict';
 
 const os = require('os');
+const path = require('path');
 const _ = require('lodash');
 const isDocker = require('is-docker');
 const fetch = require('node-fetch');
 const ciEnv = require('ci-info');
+const { isUsingTypeScriptSync } = require('@strapi/typescript-utils');
 const ee = require('../../utils/ee');
 const machineID = require('../../utils/machine-id');
 const stringifyDeep = require('./stringify-deep');
@@ -36,6 +38,9 @@ module.exports = strapi => {
   const deviceId = machineID();
   const isEE = strapi.EE === true && ee.isEE === true;
 
+  const serverRootPath = strapi.dirs.app.root;
+  const adminRootPath = path.join(strapi.dirs.app.root, 'src', 'admin');
+
   const anonymous_metadata = {
     environment: strapi.config.environment,
     os: os.type(),
@@ -47,6 +52,8 @@ module.exports = strapi => {
     version: strapi.config.get('info.strapi'),
     strapiVersion: strapi.config.get('info.strapi'),
     projectType: isEE ? 'Enterprise' : 'Community',
+    useTypescriptOnServer: isUsingTypeScriptSync(serverRootPath),
+    useTypescriptOnAdmin: isUsingTypeScriptSync(adminRootPath),
   };
 
   addPackageJsonStrapiMetadata(anonymous_metadata, strapi);

package/lib/services/server/index.js

@@ -30,7 +30,7 @@ const healthCheck = async ctx => {
 const createServer = strapi => {
   const app = createKoaApp({
     proxy: strapi.config.get('server.proxy'),
-    keys:  strapi.config.get('server.app.keys'),
+    keys: strapi.config.get('server.app.keys'),
   });
 
   const router = new Router();

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