@strapi/strapi 4.13.4 → 4.13.6

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

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