@strapi/strapi 4.13.5 → 4.13.7

package/README.md

@@ -1,23 +1,15 @@
 <p align="center">
-  <a href="https://strapi.io">
-    <picture>
-      <source
-        srcset="https://strapi.io/assets/strapi-logo-dark.svg"
-        media="(prefers-color-scheme: dark)"
-        width="318px"
-      />
-      <img
-        src="https://strapi.io/assets/strapi-logo-light.svg"
-        alt="Strapi logo"
-        width="318px"
-      />
-    </picture>
+  <a href="https://strapi.io/#gh-light-mode-only">
+    <img src="https://strapi.io/assets/strapi-logo-dark.svg" width="318px" alt="Strapi logo" />
+  </a>
+  <a href="https://strapi.io/#gh-dark-mode-only">
+    <img src="https://strapi.io/assets/strapi-logo-light.svg" width="318px" alt="Strapi logo" />
   </a>
 </p>
 
-<h3 align="center">API creation made simple, secure and fast.</h3>
-<p align="center">The most advanced open-source headless CMS to build powerful APIs with no effort.</p>
-<p align="center"><a href="https://strapi.io/demo">Try live demo</a></p>
+<h3 align="center">Open-source headless CMS, self-hosted or Cloud you’re in control.</h3>
+<p align="center">The leading open-source headless CMS, 100% JavaScript/TypeScript, flexible and fully customizable.</p>
+<p align="center"><a href="https://cloud.strapi.io/signups?source=github1">Cloud</a> · <a href="https://strapi.io/demo">Try live demo</a></p>
 <br />
 
 <p align="center">
@@ -39,18 +31,22 @@
 
 <p align="center">
   <a href="https://strapi.io">
-    <img src="https://raw.githubusercontent.com/strapi/strapi/0bcebf77b37182fe021cb59cc19be8f5db4a18ac/public/assets/administration_panel.png" alt="Administration panel" />
+    <img src="https://raw.githubusercontent.com/strapi/strapi/main/public/assets/admin-demo.gif" alt="Administration panel" />
   </a>
 </p>
 
 <br>
 
-Strapi is a free and open-source headless CMS delivering your content anywhere you need.
+Strapi Community Edition is a free and open-source headless CMS enabling you to manage any content, anywhere.
 
-- **Keep control over your data**. With Strapi, you know where your data is stored, and you keep full control at all times.
-- **Self-hosted**. You can host and scale Strapi projects the way you want. You can choose any hosting platform you want: AWS, Render, Netlify, Heroku, a VPS, or a dedicated server. You can scale as you grow, 100% independent.
-- **Database agnostic**. Strapi works with SQL databases. You can choose the database you prefer: PostgreSQL, MySQL, MariaDB, and SQLite.
-- **Customizable**. You can quickly build your logic by fully customizing APIs, routes, or plugins to fit your needs perfectly.
+- **Self-hosted or Cloud**: You can host and scale Strapi projects the way you want. You can save time by deploying to [Strapi Cloud](https://cloud.strapi.io/signups?source=github1) or deploy to the hosting platform you want**: AWS, Azure, Google Cloud, DigitalOcean.
+- **Modern Admin Pane**: Elegant, entirely customizable and a fully extensible admin panel.
+- **Multi-database support**: You can choose the database you prefer: PostgreSQL, MySQL, MariaDB, and SQLite.
+- **Customizable**: You can quickly build your logic by fully customizing APIs, routes, or plugins to fit your needs perfectly.
+- **Blazing Fast and Robust**: Built on top of Node.js and TypeScript, Strapi delivers reliable and solid performance.
+- **Front-end Agnostic**: Use any front-end framework (React, Next.js, Vue, Angular, etc.), mobile apps or even IoT.
+- **Secure by default**: Reusable policies, CORS, CSP, P3P, Xframe, XSS, and more.
+- **Powerful CLI**: Scaffold projects and APIs on the fly.
 
 ## Getting Started
 
@@ -115,13 +111,13 @@ Strapi only supports maintenance and LTS versions of Node.js. Please refer to th
 
 ## Features
 
-- **Modern Admin Panel:** Elegant, entirely customizable and a fully extensible admin panel.
-- **Secure by default:** Reusable policies, CORS, CSP, P3P, Xframe, XSS, and more.
-- **Plugins Oriented:** Install the auth system, content management, custom plugins, and more, in seconds.
-- **Blazing Fast:** Built on top of Node.js, Strapi delivers amazing performance.
-- **Front-end Agnostic:** Use any front-end framework (React, Vue, Angular, etc.), mobile apps or even IoT.
-- **Powerful CLI:** Scaffold projects and APIs on the fly.
-- **SQL databases:** Works with PostgreSQL, MySQL, MariaDB, and SQLite.
+- **Content Types Builder**: Build the most flexible publishing experience for your content managers, by giving them the freedom to create any page on the go with [fields](https://docs.strapi.io/user-docs/content-manager/writing-content#filling-up-fields), components and [Dynamic Zones](https://docs.strapi.io/user-docs/content-manager/writing-content#dynamic-zones).
+- **Media Library**: Upload your images, videos, audio or documents to the media library. Easily find the right asset, edit and reuse it.
+- **Internationalization**: The Internationalization (i18n) plugin allows Strapi users to create, manage and distribute localized content in different languages, called "locales
+- **Role Based Access Control**: Create an unlimited number of custom roles and permissions for admin and end users.
+- **GraphQL or REST**: Consume the API using REST or GraphQL
+
+You can unlock additional features such as SSO, Audit Logs, Review Workflows in [Strapi Cloud](https://cloud.strapi.io/login?source=github1) or [Strapi Enterprise](https://strapi.io/enterprise?source=github1).
 
 **[See more on our website](https://strapi.io/overview)**.
 

package/lib/commands/actions/develop/action.js

@@ -48,7 +48,7 @@ module.exports = async ({ build, watchAdmin, polling, browser }) => {
 
 const primaryProcess = async ({ distDir, appDir, build, isTSProject, watchAdmin, browser }) => {
   if (isTSProject) {
-    await buildTypeScript({ srcDir: appDir, distDir, watch: false });
+    await buildTypeScript({ srcDir: appDir, distDir, ignoreDiagnostics: true });
   }
 
   const config = loadConfiguration({ appDir, distDir });
@@ -84,7 +84,7 @@ const primaryProcess = async ({ distDir, appDir, build, isTSProject, watchAdmin,
     switch (message) {
       case 'reload':
         if (isTSProject) {
-          await buildTypeScript({ srcDir: appDir, distDir, watch: false });
+          await buildTypeScript({ srcDir: appDir, distDir, ignoreDiagnostics: true });
         }
 
         console.info('The server is restarting\n');
@@ -113,21 +113,16 @@ const workerProcess = async ({ appDir, distDir, watchAdmin, polling, isTSProject
     serveAdminPanel: !watchAdmin,
   }).load();
 
-  /**
-   * TypeScript automatic type generation upon dev server restart
-   * Its implementation, configuration and behavior can change in future releases
-   * @experimental
-   */
-  const shouldGenerateTypeScriptTypes = strapiInstance.config.get('typescript.autogenerate', false);
-
-  if (shouldGenerateTypeScriptTypes) {
-    await tsUtils.generators.generate({
-      strapi: strapiInstance,
-      pwd: appDir,
-      rootDir: undefined,
-      logger: { silent: true, debug: false },
-      artifacts: { contentTypes: true, components: true },
-    });
+  await tsUtils.generators.generate({
+    strapi: strapiInstance,
+    pwd: appDir,
+    rootDir: undefined,
+    logger: { silent: true, debug: false },
+    artifacts: { contentTypes: true, components: true },
+  });
+
+  if (isTSProject) {
+    await buildTypeScript({ srcDir: appDir, distDir, ignoreDiagnostics: false });
   }
 
   const adminWatchIgnoreFiles = strapiInstance.config.get('admin.watchIgnoreFiles', []);

package/lib/commands/actions/plugin/build-command/action.js

@@ -0,0 +1,137 @@
+'use strict';
+
+const fs = require('fs/promises');
+const boxen = require('boxen');
+const chalk = require('chalk');
+const ora = require('ora');
+const { createLogger } = require('../../../utils/logger');
+const { notifyExperimentalCommand } = require('../../../utils/helpers');
+const {
+  loadPkg,
+  validatePkg,
+  validateExportsOrdering,
+  getExportExtensionMap,
+} = require('../../../utils/pkg');
+const { createBuildContext, createBuildTasks } = require('../../../builders/packages');
+const { buildTaskHandlers } = require('../../../builders/tasks');
+
+/**
+ *
+ * @param {object} args
+ * @param {boolean} args.force
+ * @param {boolean} args.debug
+ */
+module.exports = async ({ force, debug }) => {
+  const logger = createLogger({ debug, timestamp: false });
+  try {
+    /**
+     * Notify users this is an experimental command and get them to approve first
+     * this can be opted out by setting the argument --yes
+     */
+    await notifyExperimentalCommand({ force });
+
+    const cwd = process.cwd();
+
+    /**
+     * Load the closest package.json and then verify the structure against what we expect.
+     */
+    const packageJsonLoader = ora('Verifying package.json \n').start();
+
+    const rawPkg = await loadPkg({ cwd, logger }).catch((err) => {
+      packageJsonLoader.fail();
+      logger.error(err.message);
+      logger.debug(`Path checked – ${cwd}`);
+      process.exit(1);
+    });
+
+    const validatedPkg = await validatePkg({
+      pkg: rawPkg,
+    }).catch((err) => {
+      packageJsonLoader.fail();
+      logger.error(err.message);
+      process.exit(1);
+    });
+
+    /**
+     * Validate the exports of the package incl. the order of the
+     * exports within the exports map if applicable
+     */
+    const packageJson = await validateExportsOrdering({ pkg: validatedPkg, logger }).catch(
+      (err) => {
+        packageJsonLoader.fail();
+        logger.error(err.message);
+        process.exit(1);
+      }
+    );
+
+    packageJsonLoader.succeed('Verified package.json');
+
+    /**
+     * We create tasks based on the exports of the package.json
+     * their handlers are then ran in the order of the exports map
+     * and results are logged to see gradual progress.
+     */
+
+    const buildContextLoader = ora('Creating build context \n').start();
+
+    const extMap = getExportExtensionMap();
+
+    const ctx = await createBuildContext({
+      cwd,
+      extMap,
+      logger,
+      pkg: packageJson,
+    }).catch((err) => {
+      buildContextLoader.fail();
+      logger.error(err.message);
+      process.exit(1);
+    });
+
+    logger.debug('Build context: \n', ctx);
+
+    const buildTasks = await createBuildTasks(ctx);
+
+    buildContextLoader.succeed('Created build context');
+
+    /**
+     * If the distPath already exists, clean it
+     */
+    try {
+      logger.debug(`Cleaning dist folder: ${ctx.distPath}`);
+      await fs.rm(ctx.distPath, { recursive: true, force: true });
+      logger.debug('Cleaned dist folder');
+    } catch {
+      // do nothing, it will fail if the folder does not exist
+      logger.debug('There was no dist folder to clean');
+    }
+
+    for (const task of buildTasks) {
+      /**
+       * @type {import('../../../builders/tasks').TaskHandler<any>}
+       */
+      const handler = buildTaskHandlers[task.type];
+      handler.print(ctx, task);
+
+      await handler.run(ctx, task).catch((err) => {
+        if (err instanceof Error) {
+          logger.error(err.message);
+        }
+
+        process.exit(1);
+      });
+    }
+  } catch (err) {
+    logger.error(
+      'There seems to be an unexpected error, try again with --debug for more information \n'
+    );
+    console.log(
+      chalk.red(
+        boxen(err.stack, {
+          padding: 1,
+          align: 'left',
+        })
+      )
+    );
+    process.exit(1);
+  }
+};

package/lib/commands/actions/plugin/build-command/command.js

@@ -0,0 +1,17 @@
+'use strict';
+
+const { forceOption } = require('../../../utils/commander');
+const { getLocalScript } = require('../../../utils/helpers');
+
+/**
+ * `$ strapi plugin:build`
+ * @param {import('../../../../types/core/commands').AddCommandOptions} options
+ */
+module.exports = ({ command }) => {
+  command
+    .command('plugin:build')
+    .description('Bundle your strapi plugin for publishing.')
+    .addOption(forceOption)
+    .option('-d, --debug', 'Enable debugging mode with verbose logs', false)
+    .action(getLocalScript('plugin/build-command'));
+};

package/lib/commands/actions/ts/generate-types/action.js

@@ -10,7 +10,7 @@ module.exports = async ({ debug, silent, verbose, outDir }) => {
     process.exit(1);
   }
 
-  const appContext = await strapi.compile();
+  const appContext = await strapi.compile({ ignoreDiagnostics: true });
   const app = await strapi(appContext).register();
 
   await tsUtils.generators.generate({
@@ -25,5 +25,5 @@ module.exports = async ({ debug, silent, verbose, outDir }) => {
     artifacts: { contentTypes: true, components: true },
   });
 
-  app.destroy();
+  await app.destroy();
 };

package/lib/commands/builders/packages.js

@@ -0,0 +1,252 @@
+'use strict';
+
+const path = require('path');
+const browserslistToEsbuild = require('browserslist-to-esbuild');
+
+const { parseExports } = require('../utils/pkg');
+
+/**
+ * @typedef {Object} BuildContextArgs
+ * @property {string} cwd
+ * @property {import('../utils/pkg').ExtMap} extMap
+ * @property {import('../utils/logger').Logger} logger
+ * @property {import('../utils/pkg').PackageJson} pkg
+ */
+
+/**
+ * @typedef {Object} Targets
+ * @property {string[]} node
+ * @property {string[]} web
+ * @property {string[]} *
+ */
+
+/**
+ * @typedef {Object} BuildContext
+ * @property {string} cwd
+ * @property {import('../utils/pkg').Export[]} exports
+ * @property {string[]} external
+ * @property {import('../utils/pkg').ExtMap} extMap
+ * @property {import('../utils/logger').Logger} logger
+ * @property {import('../utils/pkg').PackageJson} pkg
+ * @property {Targets} targets
+ */
+
+const DEFAULT_BROWSERS_LIST_CONFIG = [
+  'last 3 major versions',
+  'Firefox ESR',
+  'last 2 Opera  versions',
+  'not dead',
+  'node 16.0.0',
+];
+
+/**
+ * @description Create a build context for the pipeline we're creating,
+ * this is shared among tasks so they all use the same settings for core pieces
+ * such as a target, distPath, externals etc.
+ *
+ * @type {(args: BuildContextArgs) => Promise<BuildContext>}
+ */
+const createBuildContext = async ({ cwd, extMap, logger, pkg }) => {
+  const targets = {
+    '*': browserslistToEsbuild(pkg.browserslist ?? DEFAULT_BROWSERS_LIST_CONFIG),
+    node: browserslistToEsbuild(['node 16.0.0']),
+    web: ['esnext'],
+  };
+
+  const exports = parseExports({ extMap, pkg }).reduce((acc, x) => {
+    const { _path: exportPath, ...exportEntry } = x;
+
+    return { ...acc, [exportPath]: exportEntry };
+  }, {});
+
+  const external = [
+    ...(pkg.dependencies ? Object.keys(pkg.dependencies) : []),
+    ...(pkg.peerDependencies ? Object.keys(pkg.peerDependencies) : []),
+  ];
+
+  const outputPaths = Object.values(exports)
+    .flatMap((exportEntry) => {
+      return [exportEntry.import, exportEntry.require].filter(Boolean);
+    })
+    .map((p) => path.resolve(cwd, p));
+
+  const distPath = findCommonDirPath(outputPaths);
+
+  if (distPath === cwd) {
+    throw new Error(
+      'all output files must share a common parent directory which is not the root package directory'
+    );
+  }
+
+  if (!distPath) {
+    throw new Error("could not detect 'dist' path");
+  }
+
+  return {
+    logger,
+    cwd,
+    pkg,
+    exports,
+    external,
+    distPath,
+    targets,
+    extMap,
+  };
+};
+
+/**
+ * @type {(containerPath: string, itemPath: string) => boolean}
+ */
+const pathContains = (containerPath, itemPath) => {
+  return !path.relative(containerPath, itemPath).startsWith('..');
+};
+
+/**
+ * @type {(filePaths: string[]) => string | undefined}
+ */
+const findCommonDirPath = (filePaths) => {
+  /**
+   * @type {string | undefined}
+   */
+  let commonPath;
+
+  for (const filePath of filePaths) {
+    let dirPath = path.dirname(filePath);
+
+    if (!commonPath) {
+      commonPath = dirPath;
+      // eslint-disable-next-line no-continue
+      continue;
+    }
+
+    while (dirPath !== commonPath) {
+      dirPath = path.dirname(dirPath);
+
+      if (dirPath === commonPath) {
+        break;
+      }
+
+      if (pathContains(dirPath, commonPath)) {
+        commonPath = dirPath;
+        break;
+      }
+
+      if (dirPath === '.') return undefined;
+    }
+  }
+
+  return commonPath;
+};
+
+/**
+ * @typedef {import('./tasks/vite').ViteTask | import('./tasks/dts').DtsTask} BuildTask
+ */
+
+/**
+ * @description Create the build tasks for the pipeline, this
+ * comes from the exports map we've created in the build context.
+ * But handles each export line uniquely with space to add more
+ * as the standard develops.
+ *
+ * @type {(args: BuildContext) => Promise<BuildTask[]>}
+ */
+const createBuildTasks = async (ctx) => {
+  /**
+   * @type {BuildTask[]}
+   */
+  const tasks = [];
+
+  /**
+   * @type {import('./tasks/dts').DtsTask}
+   */
+  const dtsTask = {
+    type: 'build:dts',
+    entries: [],
+  };
+
+  /**
+   * @type {Record<string, import('./tasks/vite').ViteTask>}
+   */
+  const viteTasks = {};
+
+  const createViteTask = (format, runtime, { output, ...restEntry }) => {
+    const buildId = `${format}:${output}`;
+
+    if (viteTasks[buildId]) {
+      viteTasks[buildId].entries.push(restEntry);
+
+      if (output !== viteTasks[buildId].output) {
+        ctx.logger.warn(
+          'Multiple entries with different outputs for the same format are not supported. The first output will be used.'
+        );
+      }
+    } else {
+      viteTasks[buildId] = {
+        type: 'build:js',
+        format,
+        output,
+        runtime,
+        entries: [restEntry],
+      };
+    }
+  };
+
+  const exps = Object.entries(ctx.exports).map(([exportPath, exportEntry]) => ({
+    ...exportEntry,
+    _path: exportPath,
+  }));
+
+  for (const exp of exps) {
+    if (exp.types) {
+      const importId = path.join(ctx.pkg.name, exp._path);
+
+      dtsTask.entries.push({
+        importId,
+        exportPath: exp._path,
+        sourcePath: exp.source,
+        targetPath: exp.types,
+      });
+    }
+
+    /**
+     * @type {keyof Target}
+     */
+    // eslint-disable-next-line no-nested-ternary
+    const runtime = exp._path.includes('strapi-admin')
+      ? 'web'
+      : exp._path.includes('strapi-server')
+      ? 'node'
+      : '*';
+
+    if (exp.require) {
+      /**
+       * register CJS task
+       */
+      createViteTask('cjs', runtime, {
+        path: exp._path,
+        entry: exp.source,
+        output: exp.require,
+      });
+    }
+
+    if (exp.import) {
+      /**
+       * register ESM task
+       */
+      createViteTask('es', runtime, {
+        path: exp._path,
+        entry: exp.source,
+        output: exp.import,
+      });
+    }
+  }
+
+  tasks.push(dtsTask, ...Object.values(viteTasks));
+
+  return tasks;
+};
+
+module.exports = {
+  createBuildContext,
+  createBuildTasks,
+};