@strapi/strapi 4.13.5 → 4.13.7

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

@@ -0,0 +1,199 @@
+'use strict';
+
+const path = require('path');
+const chalk = require('chalk');
+const ora = require('ora');
+const ts = require('typescript');
+
+/**
+ * @description Load a tsconfig.json file and return the parsed config
+ *
+ * @internal
+ *
+ * @type {(args: { cwd: string; path: string }) => Promise<ts.ParsedCommandLine>)}
+ */
+const loadTsConfig = async ({ cwd, path }) => {
+  const configPath = ts.findConfigFile(cwd, ts.sys.fileExists, path);
+
+  if (!configPath) {
+    throw new TSConfigNotFoundError(`could not find a valid '${path}'`);
+  }
+
+  const configFile = ts.readConfigFile(configPath, ts.sys.readFile);
+
+  return ts.parseJsonConfigFileContent(configFile.config, ts.sys, cwd);
+};
+
+class TSConfigNotFoundError extends Error {
+  // eslint-disable-next-line no-useless-constructor
+  constructor(message, options) {
+    super(message, options);
+  }
+
+  get code() {
+    return 'TS_CONFIG_NOT_FOUND';
+  }
+}
+
+/**
+ * @description
+ *
+ * @internal
+ *
+ * @type {(args: { cwd: string; logger: import('../../utils/logger').Logger; outDir: string; tsconfig: ts.ParsedCommandLine }) => Promise<void>}
+ */
+const buildTypes = ({ cwd, logger, outDir, tsconfig }) => {
+  const compilerOptions = {
+    ...tsconfig.options,
+    declaration: true,
+    declarationDir: outDir,
+    emitDeclarationOnly: true,
+    noEmit: false,
+    outDir,
+  };
+
+  const program = ts.createProgram(tsconfig.fileNames, compilerOptions);
+
+  const emitResult = program.emit();
+
+  const allDiagnostics = ts.getPreEmitDiagnostics(program).concat(emitResult.diagnostics);
+
+  for (const diagnostic of allDiagnostics) {
+    if (diagnostic.file && diagnostic.start) {
+      const { line, character } = ts.getLineAndCharacterOfPosition(
+        diagnostic.file,
+        diagnostic.start
+      );
+      const message = ts.flattenDiagnosticMessageText(diagnostic.messageText, '\n');
+
+      const file = path.relative(cwd, diagnostic.file.fileName);
+
+      const output = [
+        `${chalk.cyan(file)}:${chalk.cyan(line + 1)}:${chalk.cyan(character + 1)} - `,
+        `${chalk.gray(`TS${diagnostic.code}:`)} ${message}`,
+      ].join('');
+
+      if (diagnostic.category === ts.DiagnosticCategory.Error) {
+        logger.error(output);
+      }
+
+      if (diagnostic.category === ts.DiagnosticCategory.Warning) {
+        logger.warn(output);
+      }
+
+      if (diagnostic.category === ts.DiagnosticCategory.Message) {
+        logger.info(output);
+      }
+
+      if (diagnostic.category === ts.DiagnosticCategory.Suggestion) {
+        logger.info(output);
+      }
+    } else {
+      logger.info(ts.flattenDiagnosticMessageText(diagnostic.messageText, '\n'));
+    }
+  }
+
+  if (emitResult.emitSkipped) {
+    const errors = allDiagnostics.filter((diag) => diag.category === ts.DiagnosticCategory.Error);
+
+    if (errors.length) {
+      throw new Error('Failed to compile TypeScript definitions');
+    }
+  }
+};
+
+/**
+ * @typedef {Object} DtsTaskEntry
+ * @property {string} exportPath
+ * @property {string} sourcePath
+ * @property {string} targetPath
+ */
+
+/**
+ * @typedef {Object} DtsTask
+ * @property {"build:dts"} type
+ * @property {DtsTaskEntry[]} entries
+ */
+
+/**
+ * @type {import('./index').TaskHandler<DtsTask>}
+ */
+const dtsTask = {
+  _spinner: null,
+  print(ctx, task) {
+    const entries = [
+      '   entries:',
+      ...task.entries.map((entry) =>
+        [
+          `    – `,
+          chalk.green(`${entry.importId} `),
+          `${chalk.cyan(entry.sourcePath)} ${chalk.gray('→')} ${chalk.cyan(entry.targetPath)}`,
+        ].join('')
+      ),
+      '',
+    ];
+
+    this._spinner = ora(`Building type files:\n`).start();
+
+    ctx.logger.log([...entries].join('\n'));
+  },
+  async run(ctx, task) {
+    try {
+      await Promise.all(
+        task.entries.map(async (entry) => {
+          const config = await loadTsConfig({
+            /**
+             * TODO: this will not scale and assumes all project sourcePaths are `src/index.ts`
+             * so we can go back to the "root" of the project...
+             */
+            cwd: path.join(ctx.cwd, entry.sourcePath, '..', '..'),
+            path: 'tsconfig.build.json',
+          }).catch((err) => {
+            if (err instanceof TSConfigNotFoundError) {
+              return undefined;
+            }
+
+            throw err;
+          });
+
+          if (config) {
+            ctx.logger.debug(`TS config for '${entry.sourcePath}': \n`, config);
+          } else {
+            ctx.logger.warn(
+              `You've added a types entry but no tsconfig.json was found for ${entry.targetPath}. Skipping...`
+            );
+
+            return;
+          }
+
+          const { outDir } = config.raw.compilerOptions;
+
+          if (!outDir) {
+            throw new Error("tsconfig.json is missing 'compilerOptions.outDir'");
+          }
+
+          await buildTypes({
+            cwd: ctx.cwd,
+            logger: ctx.logger,
+            outDir: path.relative(ctx.cwd, outDir),
+            tsconfig: config,
+          });
+        })
+      );
+
+      await this.success(ctx, task);
+    } catch (err) {
+      this.fail(ctx, task, err);
+    }
+  },
+  async success() {
+    this._spinner.succeed('Built type files');
+  },
+  async fail(ctx, task, err) {
+    this._spinner.fail('Failed to build type files');
+
+    throw err;
+  },
+};
+
+module.exports = { dtsTask };

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

@@ -0,0 +1,29 @@
+'use strict';
+
+const { dtsTask } = require('./dts');
+const { viteTask } = require('./vite');
+
+/**
+ * @template Task
+ * @param {Task}
+ * @returns {Task}
+ *
+ * @typedef {Object} TaskHandler
+ * @property {(ctx: import("../packages").BuildContext, task: Task) => import('ora').Ora} print
+ * @property {(ctx: import("../packages").BuildContext, task: Task) => Promise<void>} run
+ * @property {(ctx: import("../packages").BuildContext, task: Task) => Promise<void>} success
+ * @property {(ctx: import("../packages").BuildContext, task: Task, err: unknown) => Promise<void>} fail
+ * @property {import('ora').Ora | null} _spinner
+ */
+
+/**
+ * @type {{ "build:js": TaskHandler<import("./vite").ViteTask>; "build:dts": TaskHandler<import("./dts").DtsTask>; }}}
+ */
+const buildTaskHandlers = {
+  'build:js': viteTask,
+  'build:dts': dtsTask,
+};
+
+module.exports = {
+  buildTaskHandlers,
+};

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/builders/typescript.js

@@ -19,7 +19,7 @@ const cleanupDistDirectory = async (distDir) => {
   }
 };
 
-module.exports = async ({ srcDir, distDir, watch = false }) => {
+module.exports = async ({ srcDir, distDir, ignoreDiagnostics = false }) => {
   const isTSProject = await tsUtils.isUsingTypeScript(srcDir);
 
   if (!isTSProject) {
@@ -28,5 +28,5 @@ module.exports = async ({ srcDir, distDir, watch = false }) => {
 
   await cleanupDistDirectory(distDir);
 
-  return tsUtils.compile(srcDir, { watch });
+  return tsUtils.compile(srcDir, { configOptions: { ignoreDiagnostics } });
 };

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