@strapi/strapi 4.13.3 → 4.14.0-alpha.0

package/lib/commands/builders/tasks/vite.js

@@ -0,0 +1,144 @@
+'use strict';
+
+const path = require('path');
+const { build, createLogger } = require('vite');
+const react = require('@vitejs/plugin-react');
+const ora = require('ora');
+const chalk = require('chalk');
+
+/**
+ * @internal
+ *
+ * @type {(ctx: import('../packages').BuildContext, task: ViteTask) => import('vite').UserConfig}
+ */
+const resolveViteConfig = (ctx, task) => {
+  const { cwd, distPath, targets, external, extMap, pkg } = ctx;
+  const { entries, format, output, runtime } = task;
+  const outputExt = extMap[pkg.type || 'commonjs'][format];
+  const outDir = path.relative(cwd, distPath);
+
+  const customLogger = createLogger();
+  customLogger.warn = (msg) => ctx.logger.warn(msg);
+  customLogger.warnOnce = (msg) => ctx.logger.warn(msg);
+  customLogger.error = (msg) => ctx.logger.error(msg);
+
+  /**
+   * @type {import('vite').InlineConfig}
+   */
+  const config = {
+    configFile: false,
+    root: cwd,
+    mode: 'production',
+    logLevel: 'warn',
+    clearScreen: false,
+    customLogger,
+    build: {
+      sourcemap: true,
+      /**
+       * The task runner will clear this for us
+       */
+      emptyOutDir: false,
+      target: targets[runtime],
+      outDir,
+      lib: {
+        entry: entries.map((e) => e.entry),
+        formats: [format],
+        /**
+         * this enforces the file name to match what the output we've
+         * determined from the package.json exports.
+         */
+        fileName() {
+          return `${path.relative(outDir, output).replace(/\.[^/.]+$/, '')}${outputExt}`;
+        },
+      },
+      rollupOptions: {
+        external,
+        output: {
+          chunkFileNames() {
+            const parts = outputExt.split('.');
+
+            if (parts.length === 3) {
+              return `_chunks/[name]-[hash].${parts[2]}`;
+            }
+
+            return `_chunks/[name]-[hash]${outputExt}`;
+          },
+        },
+      },
+    },
+    /**
+     * We _could_ omit this, but we'd need to introduce the
+     * concept of a custom config for the scripts straight away
+     *
+     * and since this is isolated to the Strapi CLI, we can make
+     * some assumptions and add some weight until we move it outside.
+     */
+    plugins: runtime === 'node' ? [] : [react()],
+  };
+
+  return config;
+};
+
+/**
+ * @typedef {Object} ViteTaskEntry
+ * @property {string} path
+ * @property {string} entry
+ */
+
+/**
+ * @typedef {Object} ViteTask
+ * @property {"build:js"} type
+ * @property {ViteTaskEntry[]} entries
+ * @property {string} format
+ * @property {string} output
+ * @property {keyof import('../packages').Targets} runtime
+ */
+
+/**
+ * @type {import('./index').TaskHandler<ViteTask>}
+ */
+const viteTask = {
+  _spinner: null,
+  print(ctx, task) {
+    const targetLines = [
+      '   target:',
+      ...ctx.targets[task.runtime].map((t) => chalk.cyan(`    - ${t}`)),
+    ];
+    const entries = [
+      '   entries:',
+      ...task.entries.map((entry) =>
+        [
+          `    – `,
+          chalk.green(`${path.join(ctx.pkg.name, entry.path)}: `),
+          `${chalk.cyan(entry.entry)} ${chalk.gray('→')} ${chalk.cyan(task.output)}`,
+        ].join('')
+      ),
+    ];
+
+    this._spinner = ora(`Building javascript files:\n`).start();
+
+    ctx.logger.log([`  format: ${task.format}`, ...targetLines, ...entries].join('\n'));
+  },
+  async run(ctx, task) {
+    try {
+      const config = resolveViteConfig(ctx, task);
+      ctx.logger.debug('Vite config: \n', config);
+      await build(config);
+      await this.success(ctx, task);
+    } catch (err) {
+      this.fail(ctx, task, err);
+    }
+  },
+  async success() {
+    this._spinner.succeed('Built javascript files');
+  },
+  async fail(ctx, task, err) {
+    this._spinner.fail('Failed to build javascript files');
+
+    throw err;
+  },
+};
+
+module.exports = {
+  viteTask,
+};

package/lib/commands/index.js

@@ -20,6 +20,7 @@ const strapiCommands = {
   install: require('./actions/install/command'),
   'middlewares/list': require('./actions/middlewares/list/command'),
   new: require('./actions/new/command'),
+  'plugin/build': require('./actions/plugin/build-command/command'),
   'policies/list': require('./actions/policies/list/command'),
   report: require('./actions/report/command'),
   'routes/list': require('./actions/routes/list/command'),

package/lib/commands/utils/helpers.js

@@ -8,6 +8,9 @@ const { yellow, red, green } = require('chalk');
 const { isString, isArray } = require('lodash/fp');
 const resolveCwd = require('resolve-cwd');
 const { has } = require('lodash/fp');
+const { prompt } = require('inquirer');
+const boxen = require('boxen');
+const chalk = require('chalk');
 
 const bytesPerKb = 1024;
 const sizes = ['B ', 'KB', 'MB', 'GB', 'TB', 'PB'];
@@ -121,7 +124,10 @@ const assertCwdContainsStrapiProject = (name) => {
 
   try {
     const pkgJSON = require(`${process.cwd()}/package.json`);
-    if (!has('dependencies.@strapi/strapi', pkgJSON)) {
+    if (
+      !has('dependencies.@strapi/strapi', pkgJSON) &&
+      !has('devDependencies.@strapi/strapi', pkgJSON)
+    ) {
       logErrorAndExit(name);
     }
   } catch (err) {
@@ -156,6 +162,51 @@ const getLocalScript =
       });
   };
 
+/**
+ * @description Notify users this is an experimental command and get them to approve first
+ * this can be opted out by passing `yes` as a property of the args object.
+ *
+ * @type {(args?: { force?: boolean }) => Promise<void>}
+ *
+ * @example
+ * ```ts
+ * const { notifyExperimentalCommand } = require('../utils/helpers');
+ *
+ * const myCommand = async ({ force }) => {
+ *  await notifyExperimentalCommand({ force });
+ * }
+ * ```
+ */
+const notifyExperimentalCommand = async ({ force } = {}) => {
+  console.log(
+    boxen(
+      `The ${chalk.bold(
+        chalk.underline('plugin:build')
+      )} command is considered experimental, use at your own risk.`,
+      {
+        title: 'Warning',
+        padding: 1,
+        margin: 1,
+        align: 'center',
+        borderColor: 'yellow',
+        borderStyle: 'bold',
+      }
+    )
+  );
+
+  if (!force) {
+    const { confirmed } = await prompt({
+      type: 'confirm',
+      name: 'confirmed',
+      message: 'Do you want to continue?',
+    });
+
+    if (!confirmed) {
+      process.exit(0);
+    }
+  }
+};
+
 module.exports = {
   exitWith,
   assertUrlHasProtocol,
@@ -163,4 +214,5 @@ module.exports = {
   readableBytes,
   getLocalScript,
   assertCwdContainsStrapiProject,
+  notifyExperimentalCommand,
 };

package/lib/commands/utils/logger.js

@@ -0,0 +1,97 @@
+'use strict';
+
+const chalk = require('chalk');
+
+/**
+ * @typedef {{ silent?: boolean; debug?: boolean; timestamp?: boolean; }} LoggerOptions
+ */
+
+/**
+ * @typedef {object} Logger
+ * @property {number} warnings
+ * @property {number} errors
+ * @property {(...args: any[]) => void} debug
+ * @property {(...args: any[]) => void} info
+ * @property {(...args: any[]) => void} warn
+ * @property {(...args: any[]) => void} error
+ * @property {(...args: any[]) => void} log
+ */
+
+/**
+ * @type {(options: LoggerOptions) => Logger}
+ */
+const createLogger = (options = {}) => {
+  const { silent = false, debug = false, timestamp = true } = options;
+
+  const state = { errors: 0, warning: 0 };
+
+  return {
+    get warnings() {
+      return state.warning;
+    },
+
+    get errors() {
+      return state.errors;
+    },
+
+    debug(...args) {
+      if (silent || !debug) {
+        return;
+      }
+
+      console.log(
+        chalk.cyan(`[DEBUG]${timestamp ? `\t[${new Date().toISOString()}]` : ''}`),
+        ...args
+      );
+    },
+
+    info(...args) {
+      if (silent) {
+        return;
+      }
+
+      console.info(
+        chalk.blue(`[INFO]${timestamp ? `\t[${new Date().toISOString()}]` : ''}`),
+        ...args
+      );
+    },
+
+    log(...args) {
+      if (silent) {
+        return;
+      }
+
+      console.info(chalk.blue(`${timestamp ? `\t[${new Date().toISOString()}]` : ''}`), ...args);
+    },
+
+    warn(...args) {
+      state.warning += 1;
+
+      if (silent) {
+        return;
+      }
+
+      console.warn(
+        chalk.yellow(`[WARN]${timestamp ? `\t[${new Date().toISOString()}]` : ''}`),
+        ...args
+      );
+    },
+
+    error(...args) {
+      state.errors += 1;
+
+      if (silent) {
+        return;
+      }
+
+      console.error(
+        chalk.red(`[ERROR]${timestamp ? `\t[${new Date().toISOString()}]` : ''}`),
+        ...args
+      );
+    },
+  };
+};
+
+module.exports = {
+  createLogger,
+};