@strapi/upgrade 0.0.0-experimental.d362bf200f5f9359a4bbd4a549603de5ee1f04ca → 0.0.0-experimental.d834c9e658d1fb037e6da1105150593521c667cc

package/dist/index.mjs

@@ -3,7 +3,7 @@ import simpleGit from "simple-git";
 import chalk from "chalk";
 import semver from "semver";
 import { packageManager } from "@strapi/utils";
-import { cloneDeep, get, has, merge, set, omit, isEqual } from "lodash/fp";
+import { cloneDeep, get, has, merge, set, omit, isEqual, groupBy, size } from "lodash/fp";
 import fse from "fs-extra";
 import assert from "node:assert";
 import { glob } from "glob";
@@ -253,13 +253,19 @@ const rangeFromVersions = (currentVersion, target) => {
   }
   throw new Error(`Invalid target set: ${target}`);
 };
+const isValidStringifiedRange = (str) => semver.validRange(str) !== null;
+const isRangeInstance = (range) => {
+  return range instanceof semver.Range;
+};
 const index$e = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
   Version: types,
   isLiteralSemVer,
+  isRangeInstance,
   isSemVerReleaseType,
   isSemverInstance,
   isValidSemVer,
+  isValidStringifiedRange,
   rangeFactory,
   rangeFromReleaseType,
   rangeFromVersions,
@@ -320,7 +326,11 @@ const transformJSON = async (codemodPath, paths, config) => {
     timeElapsed: "",
     stats: {}
   };
-  const esbuildOptions = { extensions: [".js", ".mjs", ".ts"] };
+  const esbuildOptions = {
+    extensions: [".js", ".mjs", ".ts"],
+    hookIgnoreNodeModules: false,
+    hookMatcher: isEqual(codemodPath)
+  };
   const { unregister } = register(esbuildOptions);
   const module = require(codemodPath);
   unregister();
@@ -365,7 +375,7 @@ const index$b = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.definePrope
   jsonRunnerFactory
 }, Symbol.toStringTag, { value: "Module" }));
 const PROJECT_PACKAGE_JSON = "package.json";
-const PROJECT_DEFAULT_ALLOWED_ROOT_PATHS = ["src", "config", "public"];
+const PROJECT_DEFAULT_ALLOWED_ROOT_PATHS = ["src", "config", "public", "admin", "server"];
 const PROJECT_DEFAULT_CODE_EXTENSIONS = [
   // Source files
   "js",
@@ -418,10 +428,10 @@ class Project {
     this.refreshProjectFiles();
     return this;
   }
-  async runCodemods(codemods2, options) {
+  async runCodemods(codemods, options) {
     const runners = this.createProjectCodemodsRunners(options.dry);
     const reports2 = [];
-    for (const codemod of codemods2) {
+    for (const codemod of codemods) {
       for (const runner of runners) {
         if (runner.valid(codemod)) {
           const report = await runner.run(codemod);
@@ -480,7 +490,7 @@ class Project {
 }
 class AppProject extends Project {
   strapiVersion;
-  type = "app";
+  type = "application";
   constructor(cwd) {
     super(cwd);
     this.refreshStrapiVersion();
@@ -564,12 +574,12 @@ function assertPluginProject(project) {
     throw new Error("Project is not a plugin");
   }
 }
-const isAppProject = (project) => {
+const isApplicationProject = (project) => {
   return project instanceof AppProject;
 };
 function assertAppProject(project) {
-  if (!isAppProject(project)) {
-    throw new Error("Project is not an app");
+  if (!isApplicationProject(project)) {
+    throw new Error("Project is not an application");
   }
 }
 const index$a = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
@@ -577,7 +587,7 @@ const index$a = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.definePrope
   assertAppProject,
   assertPluginProject,
   constants: constants$3,
-  isAppProject,
+  isApplicationProject,
   isPluginProject,
   projectFactory
 }, Symbol.toStringTag, { value: "Module" }));
@@ -604,7 +614,11 @@ const path = (path2) => chalk.blue(path2);
 const version = (version2) => {
   return chalk.italic.yellow(`v${version2}`);
 };
-const versionRange = (range) => chalk.italic.yellow(range);
+const codemodUID = (uid) => {
+  return chalk.bold.cyan(uid);
+};
+const projectType = (type) => chalk.cyan(type);
+const versionRange = (range) => chalk.italic.yellow(range.raw);
 const transform = (transformFilePath) => chalk.cyan(transformFilePath);
 const highlight = (arg) => chalk.bold.underline(arg);
 const upgradeStep = (text, step) => {
@@ -636,15 +650,40 @@ const reports = (reports2) => {
   table.push(...rows);
   return table.toString();
 };
+const codemodList = (codemods) => {
+  const rows = codemods.map((codemod, index2) => {
+    const fIndex = chalk.grey(index2);
+    const fVersion = chalk.magenta(codemod.version);
+    const fKind = chalk.yellow(codemod.kind);
+    const fName = chalk.blue(codemod.format());
+    const fUID = codemodUID(codemod.uid);
+    return [fIndex, fVersion, fKind, fName, fUID];
+  });
+  const table = new CliTable3({
+    style: { compact: true },
+    head: [
+      chalk.bold.grey("N°"),
+      chalk.bold.magenta("Version"),
+      chalk.bold.yellow("Kind"),
+      chalk.bold.blue("Name"),
+      chalk.bold.cyan("UID")
+    ]
+  });
+  table.push(...rows);
+  return table.toString();
+};
 const durationMs = (elapsedMs) => {
   const elapsedSeconds = (elapsedMs / ONE_SECOND_MS).toFixed(3);
   return `${elapsedSeconds}s`;
 };
 const index$8 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
+  codemodList,
+  codemodUID,
   durationMs,
   highlight,
   path,
+  projectType,
   reports,
   transform,
   upgradeStep,
@@ -667,6 +706,7 @@ const constants$2 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineP
   CODEMOD_JSON_SUFFIX
 }, Symbol.toStringTag, { value: "Module" }));
 class Codemod {
+  uid;
   kind;
   version;
   baseDirectory;
@@ -678,9 +718,27 @@ class Codemod {
     this.baseDirectory = options.baseDirectory;
     this.filename = options.filename;
     this.path = path$1.join(this.baseDirectory, this.version.raw, this.filename);
-  }
-  format() {
-    return this.filename.replace(`.${CODEMOD_CODE_SUFFIX}.${CODEMOD_EXTENSION}`, "").replace(`.${CODEMOD_JSON_SUFFIX}.${CODEMOD_EXTENSION}`, "").replaceAll("-", " ");
+    this.uid = this.createUID();
+  }
+  createUID() {
+    const name = this.format({ stripExtension: true, stripKind: true, stripHyphens: false });
+    const kind = this.kind;
+    const version2 = this.version.raw;
+    return `${version2}-${name}-${kind}`;
+  }
+  format(options) {
+    const { stripExtension = true, stripKind = true, stripHyphens = true } = options ?? {};
+    let formatted = this.filename;
+    if (stripExtension) {
+      formatted = formatted.replace(new RegExp(`\\.${CODEMOD_EXTENSION}$`, "i"), "");
+    }
+    if (stripKind) {
+      formatted = formatted.replace(`.${CODEMOD_CODE_SUFFIX}`, "").replace(`.${CODEMOD_JSON_SUFFIX}`, "");
+    }
+    if (stripHyphens) {
+      formatted = formatted.replaceAll("-", " ");
+    }
+    return formatted;
   }
 }
 const codemodFactory = (options) => new Codemod(options);
@@ -689,6 +747,20 @@ const index$7 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.definePrope
   codemodFactory,
   constants: constants$2
 }, Symbol.toStringTag, { value: "Module" }));
+const INTERNAL_CODEMODS_DIRECTORY = path$1.join(
+  __dirname,
+  // upgrade/dist
+  "..",
+  // upgrade
+  "resources",
+  // upgrade/resources
+  "codemods"
+  // upgrade/resources/codemods
+);
+const constants$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  INTERNAL_CODEMODS_DIRECTORY
+}, Symbol.toStringTag, { value: "Module" }));
 class CodemodRepository {
   groups;
   versions;
@@ -707,29 +779,47 @@ class CodemodRepository {
   count(version2) {
     return this.findByVersion(version2).length;
   }
-  countRange(range) {
-    return this.findByRange(range).length;
-  }
-  exists(version2) {
+  versionExists(version2) {
     return version2.raw in this.groups;
   }
-  findByRange(range) {
+  has(uid) {
+    const result = this.find({ uids: [uid] });
+    if (result.length !== 1) {
+      return false;
+    }
+    const { codemods } = result[0];
+    return codemods.length === 1 && codemods[0].uid === uid;
+  }
+  find(q) {
     const entries = Object.entries(this.groups);
-    return entries.filter(([version2]) => range.test(version2)).map(([version2, codemods2]) => ({
+    return entries.filter(maybeFilterByRange).map(([version2, codemods]) => ({
       version: semVerFactory(version2),
-      codemods: codemods2
-    }));
+      // Filter by UID if provided in the query
+      codemods: codemods.filter(maybeFilterByUIDs)
+    })).filter(({ codemods }) => codemods.length > 0);
+    function maybeFilterByRange([version2]) {
+      if (!isRangeInstance(q.range)) {
+        return true;
+      }
+      return q.range.test(version2);
+    }
+    function maybeFilterByUIDs(codemod) {
+      if (q.uids === void 0) {
+        return true;
+      }
+      return q.uids.includes(codemod.uid);
+    }
   }
   findByVersion(version2) {
     const literalVersion = version2.raw;
-    const codemods2 = this.groups[literalVersion];
-    return codemods2 ?? [];
+    const codemods = this.groups[literalVersion];
+    return codemods ?? [];
   }
   findAll() {
     const entries = Object.entries(this.groups);
-    return entries.map(([version2, codemods2]) => ({
+    return entries.map(([version2, codemods]) => ({
       version: semVerFactory(version2),
-      codemods: codemods2
+      codemods
     }));
   }
   refreshAvailableVersions() {
@@ -761,18 +851,9 @@ const parseCodemodKindFromFilename = (filename) => {
   assert(CODEMOD_ALLOWED_SUFFIXES.includes(kind));
   return kind;
 };
-const codemodRepositoryFactory = (cwd) => new CodemodRepository(cwd);
-const INTERNAL_CODEMODS_DIRECTORY = path$1.join(
-  __dirname,
-  "..",
-  "..",
-  "resources",
-  "codemods"
-);
-const constants$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
-  __proto__: null,
-  INTERNAL_CODEMODS_DIRECTORY
-}, Symbol.toStringTag, { value: "Module" }));
+const codemodRepositoryFactory = (cwd = INTERNAL_CODEMODS_DIRECTORY) => {
+  return new CodemodRepository(cwd);
+};
 const index$6 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
   codemodRepositoryFactory,
@@ -807,40 +888,59 @@ class CodemodRunner {
     this.isDry = enabled;
     return this;
   }
-  async run(codemodsDirectory) {
+  createRepository(codemodsDirectory) {
     const repository = codemodRepositoryFactory(
       codemodsDirectory ?? INTERNAL_CODEMODS_DIRECTORY
     );
     repository.refresh();
-    const allVersionedCodemods = this.range ? repository.findByRange(this.range) : repository.findAll();
-    const versionedCodemods = this.selectCodemodsCallback ? await this.selectCodemodsCallback(allVersionedCodemods) : allVersionedCodemods;
-    const hasCodemodsToRun = versionedCodemods.length > 0;
-    if (!hasCodemodsToRun) {
-      if (this.range) {
-        this.logger?.debug(`Found no codemods to run for ${versionRange(this.range)}`);
-      } else {
-        this.logger?.debug(`Found no codemods to run`);
-      }
-      return successReport$1();
-    }
-    if (this.range) {
-      this.logger?.debug(
-        `Found codemods for ${highlight(versionedCodemods.length)} version(s) using ${this.range}`
+    return repository;
+  }
+  async safeRunAndReport(codemods) {
+    if (this.isDry) {
+      this.logger?.warn?.(
+        "Running the codemods in dry mode. No files will be modified during the process."
       );
-    } else {
-      this.logger?.debug(`Found codemods for ${highlight(versionedCodemods.length)} version(s)`);
     }
-    versionedCodemods.forEach(
-      ({ version: version$1, codemods: codemods22 }) => this.logger?.debug(`- ${version(version$1)} (${codemods22.length})`)
-    );
-    const codemods2 = versionedCodemods.map(({ codemods: codemods22 }) => codemods22).flat();
     try {
-      const reports$1 = await this.project.runCodemods(codemods2, { dry: this.isDry });
-      this.logger?.raw(reports(reports$1));
+      const reports$1 = await this.project.runCodemods(codemods, { dry: this.isDry });
+      this.logger?.raw?.(reports(reports$1));
+      if (!this.isDry) {
+        const nbAffectedTotal = reports$1.flatMap((report) => report.report.ok).reduce((acc, nb) => acc + nb, 0);
+        this.logger?.debug?.(
+          `Successfully ran ${highlight(codemods.length)} codemod(s), ${highlight(nbAffectedTotal)} change(s) have been detected`
+        );
+      }
+      return successReport$1();
     } catch (e) {
       return erroredReport$1(unknownToError(e));
     }
-    return successReport$1();
+  }
+  async runByUID(uid, codemodsDirectory) {
+    const repository = this.createRepository(codemodsDirectory);
+    if (!repository.has(uid)) {
+      throw new Error(`Unknown codemod UID provided: ${uid}`);
+    }
+    const codemods = repository.find({ uids: [uid] }).flatMap(({ codemods: codemods2 }) => codemods2);
+    return this.safeRunAndReport(codemods);
+  }
+  async run(codemodsDirectory) {
+    const repository = this.createRepository(codemodsDirectory);
+    const codemodsInRange = repository.find({ range: this.range });
+    const selectedCodemods = this.selectCodemodsCallback ? await this.selectCodemodsCallback(codemodsInRange) : codemodsInRange;
+    if (selectedCodemods.length === 0) {
+      this.logger?.debug?.(`Found no codemods to run for ${versionRange(this.range)}`);
+      return successReport$1();
+    }
+    const codemods = selectedCodemods.flatMap(({ codemods: codemods2 }) => codemods2);
+    const codemodsByVersion = groupBy("version", codemods);
+    const fRange = versionRange(this.range);
+    this.logger?.debug?.(
+      `Found ${highlight(codemods.length)} codemods for ${highlight(size(codemodsByVersion))} version(s) using ${fRange}`
+    );
+    for (const [version$1, codemods2] of Object.entries(codemodsByVersion)) {
+      this.logger?.debug?.(`- ${version(semVerFactory(version$1))} (${codemods2.length})`);
+    }
+    return this.safeRunAndReport(codemods);
   }
 }
 const codemodRunnerFactory = (project, range) => {
@@ -879,7 +979,7 @@ class Upgrader {
     this.codemodsTarget = semVerFactory(
       `${this.target.major}.${this.target.minor}.${this.target.patch}`
     );
-    this.logger?.debug(
+    this.logger?.debug?.(
       `The codemods target has been synced with the upgrade target. The codemod runner will now look for ${version(
         this.codemodsTarget
       )}`
@@ -888,7 +988,7 @@ class Upgrader {
   }
   overrideCodemodsTarget(target) {
     this.codemodsTarget = target;
-    this.logger?.debug(
+    this.logger?.debug?.(
       `Overriding the codemods target. The codemod runner will now look for ${version(target)}`
     );
     return this;
@@ -908,40 +1008,40 @@ class Upgrader {
   addRequirement(requirement) {
     this.requirements.push(requirement);
     const fRequired = requirement.isRequired ? "(required)" : "(optional)";
-    this.logger?.debug(
+    this.logger?.debug?.(
       `Added a new requirement to the upgrade: ${highlight(requirement.name)} ${fRequired}`
     );
     return this;
   }
   async upgrade() {
-    this.logger?.info(
+    this.logger?.info?.(
       `Upgrading from ${version(this.project.strapiVersion)} to ${version(this.target)}`
     );
     if (this.isDry) {
-      this.logger?.warn(
+      this.logger?.warn?.(
         "Running the upgrade in dry mode. No files will be modified during the process."
       );
     }
     const range = rangeFromVersions(this.project.strapiVersion, this.target);
     const codemodsRange = rangeFromVersions(this.project.strapiVersion, this.codemodsTarget);
     const npmVersionsMatches = this.npmPackage?.findVersionsInRange(range) ?? [];
-    this.logger?.debug(
+    this.logger?.debug?.(
       `Found ${highlight(npmVersionsMatches.length)} versions satisfying ${versionRange(range)}`
     );
     try {
-      this.logger?.info(upgradeStep("Checking requirement", [1, 4]));
+      this.logger?.info?.(upgradeStep("Checking requirement", [1, 4]));
       await this.checkRequirements(this.requirements, {
         npmVersionsMatches,
         project: this.project,
         target: this.target
       });
-      this.logger?.info(upgradeStep("Applying the latest code modifications", [2, 4]));
+      this.logger?.info?.(upgradeStep("Applying the latest code modifications", [2, 4]));
       await this.runCodemods(codemodsRange);
-      this.logger?.debug("Refreshing project information...");
+      this.logger?.debug?.("Refreshing project information...");
       this.project.refresh();
-      this.logger?.info(upgradeStep("Upgrading Strapi dependencies", [3, 4]));
+      this.logger?.info?.(upgradeStep("Upgrading Strapi dependencies", [3, 4]));
       await this.updateDependencies();
-      this.logger?.info(upgradeStep("Installing dependencies", [4, 4]));
+      this.logger?.info?.(upgradeStep("Installing dependencies", [4, 4]));
       await this.installDependencies();
     } catch (e) {
       return erroredReport(unknownToError(e));
@@ -974,7 +1074,7 @@ class Upgrader {
     if (requirement.isRequired) {
       throw error;
     }
-    this.logger?.warn(warningMessage);
+    this.logger?.warn?.(warningMessage);
     const response = await this.confirmationCallback?.(confirmationMessage);
     if (!response) {
       throw error;
@@ -985,9 +1085,11 @@ class Upgrader {
     const json = createJSONTransformAPI(packageJSON);
     const dependencies = json.get("dependencies", {});
     const strapiDependencies = this.getScopedStrapiDependencies(dependencies);
-    this.logger?.debug(`Found ${highlight(strapiDependencies.length)} dependency(ies) to update`);
+    this.logger?.debug?.(
+      `Found ${highlight(strapiDependencies.length)} dependency(ies) to update`
+    );
     strapiDependencies.forEach(
-      (dependency) => this.logger?.debug(`- ${dependency[0]} (${dependency[1]} -> ${this.target})`)
+      (dependency) => this.logger?.debug?.(`- ${dependency[0]} (${dependency[1]} -> ${this.target})`)
     );
     if (strapiDependencies.length === 0) {
       return;
@@ -995,7 +1097,7 @@ class Upgrader {
     strapiDependencies.forEach(([name]) => json.set(`dependencies.${name}`, this.target.raw));
     const updatedPackageJSON = json.root();
     if (this.isDry) {
-      this.logger?.debug(`Skipping dependencies update (${chalk.italic("dry mode")})`);
+      this.logger?.debug?.(`Skipping dependencies update (${chalk.italic("dry mode")})`);
       return;
     }
     await saveJSON(packageJSONPath, updatedPackageJSON);
@@ -1015,9 +1117,9 @@ class Upgrader {
   async installDependencies() {
     const projectPath = this.project.cwd;
     const packageManagerName = await packageManager.getPreferred(projectPath);
-    this.logger?.debug(`Using ${highlight(packageManagerName)} as package manager`);
+    this.logger?.debug?.(`Using ${highlight(packageManagerName)} as package manager`);
     if (this.isDry) {
-      this.logger?.debug(`Skipping dependencies installation (${chalk.italic("dry mode")}`);
+      this.logger?.debug?.(`Skipping dependencies installation (${chalk.italic("dry mode")}`);
       return;
     }
     await packageManager.installDependencies(projectPath, packageManagerName, {
@@ -1116,7 +1218,7 @@ const upgrade = async (options) => {
   const { logger, codemodsTarget } = options;
   const cwd = path$1.resolve(options.cwd ?? process.cwd());
   const project = projectFactory(cwd);
-  if (!isAppProject(project)) {
+  if (!isApplicationProject(project)) {
     throw new Error(
       `The "${options.target}" upgrade can only be run on a Strapi project; for plugins, please use "codemods".`
     );
@@ -1138,20 +1240,7 @@ const upgrade = async (options) => {
   timer.stop();
   logger.info(`Completed in ${durationMs(timer.elapsedMs)}`);
 };
-const codemods = async (options) => {
-  const timer = timerFactory();
-  const { logger } = options;
-  const cwd = path$1.resolve(options.cwd ?? process.cwd());
-  const project = projectFactory(cwd);
-  const range = isAppProject(project) ? getRangeFromTarget(project.strapiVersion, options.target) : void 0;
-  const codemodRunner = codemodRunnerFactory(project, range).dry(options.dry ?? false).onSelectCodemods(options.selectCodemods ?? null).setLogger(logger);
-  const executionReport = await codemodRunner.run();
-  if (!executionReport.success) {
-    throw executionReport.error;
-  }
-  timer.stop();
-  logger.info(`Completed in ${timer.elapsedMs}`);
-};
+const resolvePath = (cwd) => path$1.resolve(cwd ?? process.cwd());
 const getRangeFromTarget = (currentVersion, target) => {
   if (isSemverInstance(target)) {
     return rangeFactory(target);
@@ -1168,9 +1257,60 @@ const getRangeFromTarget = (currentVersion, target) => {
       throw new Error(`Invalid target set: ${target}`);
   }
 };
+const findRangeFromTarget = (project, target) => {
+  if (isRangeInstance(target)) {
+    return target;
+  }
+  if (isApplicationProject(project)) {
+    return getRangeFromTarget(project.strapiVersion, target);
+  }
+  return rangeFactory("*");
+};
+const runCodemods = async (options) => {
+  const timer = timerFactory();
+  const { logger, uid } = options;
+  const cwd = resolvePath(options.cwd);
+  const project = projectFactory(cwd);
+  const range = findRangeFromTarget(project, options.target);
+  logger.debug(`Project: ${projectType(project.type)} found in ${path(cwd)}`);
+  logger.debug(`Range: set to ${versionRange(range)}`);
+  const codemodRunner = codemodRunnerFactory(project, range).dry(options.dry ?? false).onSelectCodemods(options.selectCodemods ?? null).setLogger(logger);
+  let report;
+  if (uid !== void 0) {
+    logger.debug(`Running a single codemod: ${codemodUID(uid)}`);
+    report = await codemodRunner.runByUID(uid);
+  } else {
+    report = await codemodRunner.run();
+  }
+  if (!report.success) {
+    throw report.error;
+  }
+  timer.stop();
+  logger.info(`Completed in ${timer.elapsedMs}`);
+};
+const listCodemods = async (options) => {
+  const { logger, target } = options;
+  const cwd = resolvePath(options.cwd);
+  const project = projectFactory(cwd);
+  const range = findRangeFromTarget(project, target);
+  logger.debug(`Project: ${projectType(project.type)} found in ${path(cwd)}`);
+  logger.debug(`Range: set to ${versionRange(range)}`);
+  const repo = codemodRepositoryFactory();
+  repo.refresh();
+  const groups = repo.find({ range });
+  const codemods = groups.flatMap((collection) => collection.codemods);
+  logger.debug(`Found ${highlight(codemods.length)} codemods`);
+  if (codemods.length === 0) {
+    logger.info(`Found no codemods matching ${versionRange(range)}`);
+    return;
+  }
+  const fCodemods = codemodList(codemods);
+  logger.raw(fCodemods);
+};
 const index$4 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  codemods,
+  listCodemods,
+  runCodemods,
   upgrade
 }, Symbol.toStringTag, { value: "Module" }));
 class Logger {