@strapi/strapi 4.2.0 → 4.3.0-beta.1

package/lib/services/server/middleware.js

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

package/lib/services/utils/upload-files.js

@@ -3,7 +3,7 @@
 const _ = require('lodash');
 
 /**
- * Upload files and like them to an entity
+ * Upload files and link them to an entity
  * @param {string} uid model uid
  * @param {object} entity entity created
  * @param {object} files files to upload

package/lib/types/strapi.d.ts

@@ -0,0 +1,370 @@
+import type Koa from 'koa';
+
+import type { StringMap } from './utils';
+import type { GenericController } from '../core-api/controller'
+
+/**
+ * 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<GenericController>;
+
+  /**
+   * Find a controller using its unique identifier
+   */
+  controller(uid: string): GenericController | 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;
+
+  /**
+   * Main Strapi container holding all the registries and providers (config, content-types, services, policies, etc...)
+   */
+  container: any;
+
+  /**
+   * References to all the directories handled by Strapi 
+   */
+  dirs: StrapiDirectories;
+
+  /**
+   * Internal flag used to check if the application has been loaded
+   */
+  isLoaded: boolean;
+
+  /**
+   * Fully reload the application
+   */
+  reload(): void;
+
+  /**
+   * Holds a reference to the Koa application and the http server used by Strapi
+   */
+  server: any;
+
+  /**
+   * Strapi util used to manage application files
+   */
+  fs: any;
+
+  /**
+   * Event hub used to send and receive events from anywhere in the application
+   */
+  eventHub: any;
+
+  /**
+   * Internal util used to log stats and messages on application Startup
+   */
+  startupLogger: any;
+
+  /**
+   * Strapi logger used to send errors, warning or information messages 
+   */
+  log: any;
+
+
+  /**
+   * Used to manage cron within Strapi
+   */
+  cron: any;
+
+  /**
+   * Telemetry util used to collect anonymous data on the application usage
+   */
+  telemetry: any;
+}
+
+export interface Lifecycles {
+  REGISTER: 'register';
+  BOOTSTRAP: 'bootstrap';
+  DESTROY: 'destroy';
+}
+
+export interface StrapiDirectories {
+  static: {
+    public: string;
+  };
+  app: {
+    root: string;
+    src: string;
+    api: string;
+    components: string;
+    extensions: string;
+    policies: string;
+    middlewares: string;
+    config: string;
+  };
+  dist: {
+    root: string;
+    src: string;
+    api: string;
+    components: string;
+    extensions: string;
+    policies: string;
+    middlewares: string;
+    config: string;
+  };
+}

package/lib/types/utils.d.ts

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

package/lib/utils/get-dirs.js

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

package/lib/utils/import-default.js

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

package/lib/utils/index.js

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

package/lib/utils/lifecycles.js

@@ -0,0 +1,15 @@
+'use strict';
+
+/**
+ * A map of all the available Strapi lifecycles
+ * @type {import('@strapi/strapi').Core.Lifecycles}
+ */
+const LIFECYCLES = {
+  REGISTER: 'register',
+  BOOTSTRAP: 'bootstrap',
+  DESTROY: 'destroy',
+};
+
+module.exports = {
+  LIFECYCLES,
+};

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

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strapi/strapi",
-  "version": "4.2.0",
+  "version": "4.3.0-beta.1",
   "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,16 +80,17 @@
   "dependencies": {
     "@koa/cors": "3.1.0",
     "@koa/router": "10.1.1",
-    "@strapi/admin": "4.2.0",
-    "@strapi/database": "4.2.0",
-    "@strapi/generate-new": "4.2.0",
-    "@strapi/generators": "4.2.0",
-    "@strapi/logger": "4.2.0",
-    "@strapi/plugin-content-manager": "4.2.0",
-    "@strapi/plugin-content-type-builder": "4.2.0",
-    "@strapi/plugin-email": "4.2.0",
-    "@strapi/plugin-upload": "4.2.0",
-    "@strapi/utils": "4.2.0",
+    "@strapi/admin": "4.3.0-beta.1",
+    "@strapi/database": "4.3.0-beta.1",
+    "@strapi/generate-new": "4.3.0-beta.1",
+    "@strapi/generators": "4.3.0-beta.1",
+    "@strapi/logger": "4.3.0-beta.1",
+    "@strapi/plugin-content-manager": "4.3.0-beta.1",
+    "@strapi/plugin-content-type-builder": "4.3.0-beta.1",
+    "@strapi/plugin-email": "4.3.0-beta.1",
+    "@strapi/plugin-upload": "4.3.0-beta.1",
+    "@strapi/typescript-utils": "4.3.0-beta.1",
+    "@strapi/utils": "4.3.0-beta.1",
     "bcryptjs": "2.4.3",
     "boxen": "5.1.2",
     "chalk": "4.1.2",
@@ -131,11 +132,12 @@
     "uuid": "^3.3.2"
   },
   "devDependencies": {
-    "supertest": "^6.1.6"
+    "supertest": "^6.1.6",
+    "typescript": "4.6.2"
   },
   "engines": {
     "node": ">=14.19.1 <=16.x.x",
     "npm": ">=6.0.0"
   },
-  "gitHead": "12c8ee3b2d95fe417de4d939db0311a0513bd8da"
+  "gitHead": "9d6555398960c39159d66bb4eea3bcb0362e37e3"
 }