@strapi/upgrade 0.0.0-experimental.e3e48deb89bd0a1b6cc69b698696566fa7854a95 → 0.0.0-experimental.e8d8fc824d0f6a695b2a9ebaa4680ed21c3645ca

package/dist/index.js

@@ -1,138 +1,26 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const path$1 = require("node:path");
-const simpleGit = require("simple-git");
+const CliTable3 = require("cli-table3");
 const chalk = require("chalk");
+const assert = require("node:assert");
 const semver = require("semver");
-const utils = require("@strapi/utils");
-const fp = require("lodash/fp");
 const fse = require("fs-extra");
-const assert = require("node:assert");
-const glob = require("glob");
+const fastglob = require("fast-glob");
 const Runner = require("jscodeshift/src/Runner");
+const fp = require("lodash/fp");
 const node = require("esbuild-register/dist/node");
-const CliTable3 = require("cli-table3");
+const utils = require("@strapi/utils");
+const simpleGit = require("simple-git");
 const _interopDefault = (e) => e && e.__esModule ? e : { default: e };
 const path__default = /* @__PURE__ */ _interopDefault(path$1);
-const simpleGit__default = /* @__PURE__ */ _interopDefault(simpleGit);
+const CliTable3__default = /* @__PURE__ */ _interopDefault(CliTable3);
 const chalk__default = /* @__PURE__ */ _interopDefault(chalk);
+const assert__default = /* @__PURE__ */ _interopDefault(assert);
 const semver__default = /* @__PURE__ */ _interopDefault(semver);
 const fse__default = /* @__PURE__ */ _interopDefault(fse);
-const assert__default = /* @__PURE__ */ _interopDefault(assert);
-const CliTable3__default = /* @__PURE__ */ _interopDefault(CliTable3);
-class Requirement {
-  isRequired;
-  name;
-  testCallback;
-  children;
-  constructor(name, testCallback, isRequired) {
-    this.name = name;
-    this.testCallback = testCallback;
-    this.isRequired = isRequired ?? true;
-    this.children = [];
-  }
-  setChildren(children) {
-    this.children = children;
-    return this;
-  }
-  addChild(child) {
-    this.children.push(child);
-    return this;
-  }
-  asOptional() {
-    const newInstance = requirementFactory(this.name, this.testCallback, false);
-    newInstance.setChildren(this.children);
-    return newInstance;
-  }
-  asRequired() {
-    const newInstance = requirementFactory(this.name, this.testCallback, true);
-    newInstance.setChildren(this.children);
-    return newInstance;
-  }
-  async test(context) {
-    try {
-      await this.testCallback?.(context);
-      return ok();
-    } catch (e) {
-      if (e instanceof Error) {
-        return errored(e);
-      }
-      if (typeof e === "string") {
-        return errored(new Error(e));
-      }
-      return errored(new Error("Unknown error"));
-    }
-  }
-}
-const ok = () => ({ pass: true, error: null });
-const errored = (error) => ({ pass: false, error });
-const requirementFactory = (name, testCallback, isRequired) => new Requirement(name, testCallback, isRequired);
-const index$g = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
-  __proto__: null,
-  requirementFactory
-}, Symbol.toStringTag, { value: "Module" }));
-const REQUIRE_AVAILABLE_NEXT_MAJOR = requirementFactory(
-  "REQUIRE_AVAILABLE_NEXT_MAJOR",
-  (context) => {
-    const { project, target } = context;
-    const currentMajor = project.strapiVersion.major;
-    const targetedMajor = target.major;
-    if (targetedMajor === currentMajor) {
-      throw new Error(`You're already on the latest major version (v${currentMajor})`);
-    }
-  }
-);
-const REQUIRE_LATEST_FOR_CURRENT_MAJOR = requirementFactory(
-  "REQUIRE_LATEST_FOR_CURRENT_MAJOR",
-  (context) => {
-    const { project, target, npmVersionsMatches } = context;
-    if (npmVersionsMatches.length !== 1) {
-      const invalidVersions = npmVersionsMatches.slice(0, -1);
-      const invalidVersionsAsSemVer = invalidVersions.map((v) => v.version);
-      const nbInvalidVersions = npmVersionsMatches.length;
-      const currentMajor = project.strapiVersion.major;
-      throw new Error(
-        `Doing a major upgrade requires to be on the latest v${currentMajor} version, but found ${nbInvalidVersions} versions between the current one and ${target}: ${invalidVersionsAsSemVer}`
-      );
-    }
-  }
-);
-const REQUIRE_GIT_CLEAN_REPOSITORY = requirementFactory(
-  "REQUIRE_GIT_CLEAN_REPOSITORY",
-  async (context) => {
-    const git = simpleGit__default.default({ baseDir: context.project.cwd });
-    const status = await git.status();
-    if (!status.isClean()) {
-      throw new Error(
-        "Repository is not clean. Please commit or stash any changes before upgrading"
-      );
-    }
-  }
-);
-const REQUIRE_GIT_REPOSITORY = requirementFactory(
-  "REQUIRE_GIT_REPOSITORY",
-  async (context) => {
-    const git = simpleGit__default.default({ baseDir: context.project.cwd });
-    const isRepo = await git.checkIsRepo();
-    if (!isRepo) {
-      throw new Error("Not a git repository (or any of the parent directories)");
-    }
-  }
-).addChild(REQUIRE_GIT_CLEAN_REPOSITORY.asOptional());
-const REQUIRE_GIT_INSTALLED = requirementFactory(
-  "REQUIRE_GIT_INSTALLED",
-  async (context) => {
-    const git = simpleGit__default.default({ baseDir: context.project.cwd });
-    try {
-      await git.version();
-    } catch {
-      throw new Error("Git is not installed");
-    }
-  }
-).addChild(REQUIRE_GIT_REPOSITORY.asOptional());
-const REQUIRE_GIT = requirementFactory("REQUIRE_GIT", null).addChild(
-  REQUIRE_GIT_INSTALLED.asOptional()
-);
+const fastglob__default = /* @__PURE__ */ _interopDefault(fastglob);
+const simpleGit__default = /* @__PURE__ */ _interopDefault(simpleGit);
 class Timer {
   interval;
   constructor() {
@@ -163,55 +51,101 @@ const constants$4 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineP
   __proto__: null,
   ONE_SECOND_MS
 }, Symbol.toStringTag, { value: "Module" }));
-const index$f = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+const index$g = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
   constants: constants$4,
   timerFactory
 }, Symbol.toStringTag, { value: "Module" }));
-class JSONTransformAPI {
-  json;
-  constructor(json) {
-    this.json = fp.cloneDeep(json);
-  }
-  get(path2, defaultValue) {
-    if (!path2) {
-      return this.root();
-    }
-    return fp.cloneDeep(fp.get(path2, this.json) ?? defaultValue);
-  }
-  has(path2) {
-    return fp.has(path2, this.json);
-  }
-  merge(other) {
-    this.json = fp.merge(other, this.json);
-    return this;
-  }
-  root() {
-    return fp.cloneDeep(this.json);
-  }
-  set(path2, value) {
-    this.json = fp.set(path2, value, this.json);
-    return this;
-  }
-  remove(path2) {
-    this.json = fp.omit(path2, this.json);
-    return this;
-  }
-}
-const createJSONTransformAPI = (object) => new JSONTransformAPI(object);
-const readJSON = async (path2) => {
-  const buffer = await fse__default.default.readFile(path2);
-  return JSON.parse(buffer.toString());
+const path = (path2) => chalk__default.default.blue(path2);
+const version = (version2) => {
+  return chalk__default.default.italic.yellow(`v${version2}`);
 };
-const saveJSON = async (path2, json) => {
-  const jsonAsString = `${JSON.stringify(json, null, 2)}
-`;
-  await fse__default.default.writeFile(path2, jsonAsString);
+const codemodUID = (uid) => {
+  return chalk__default.default.bold.cyan(uid);
+};
+const projectDetails = (project) => {
+  return `Project: TYPE=${projectType(project.type)}; CWD=${path(project.cwd)}; PATHS=${project.paths.map(path)}`;
+};
+const projectType = (type) => chalk__default.default.cyan(type);
+const versionRange = (range) => chalk__default.default.italic.yellow(range.raw);
+const transform = (transformFilePath) => chalk__default.default.cyan(transformFilePath);
+const highlight = (arg) => chalk__default.default.bold.underline(arg);
+const upgradeStep = (text, step) => {
+  return chalk__default.default.bold(`(${step[0]}/${step[1]}) ${text}...`);
+};
+const reports = (reports2) => {
+  const rows = reports2.map(({ codemod, report }, i) => {
+    const fIndex = chalk__default.default.grey(i);
+    const fVersion = chalk__default.default.magenta(codemod.version);
+    const fKind = chalk__default.default.yellow(codemod.kind);
+    const fFormattedTransformPath = chalk__default.default.cyan(codemod.format());
+    const fTimeElapsed = i === 0 ? `${report.timeElapsed}s ${chalk__default.default.dim.italic("(cold start)")}` : `${report.timeElapsed}s`;
+    const fAffected = report.ok > 0 ? chalk__default.default.green(report.ok) : chalk__default.default.grey(0);
+    const fUnchanged = report.ok === 0 ? chalk__default.default.red(report.nochange) : chalk__default.default.grey(report.nochange);
+    return [fIndex, fVersion, fKind, fFormattedTransformPath, fAffected, fUnchanged, fTimeElapsed];
+  });
+  const table = new CliTable3__default.default({
+    style: { compact: true },
+    head: [
+      chalk__default.default.bold.grey("N°"),
+      chalk__default.default.bold.magenta("Version"),
+      chalk__default.default.bold.yellow("Kind"),
+      chalk__default.default.bold.cyan("Name"),
+      chalk__default.default.bold.green("Affected"),
+      chalk__default.default.bold.red("Unchanged"),
+      chalk__default.default.bold.blue("Duration")
+    ]
+  });
+  table.push(...rows);
+  return table.toString();
+};
+const codemodList = (codemods) => {
+  const rows = codemods.map((codemod, index2) => {
+    const fIndex = chalk__default.default.grey(index2);
+    const fVersion = chalk__default.default.magenta(codemod.version);
+    const fKind = chalk__default.default.yellow(codemod.kind);
+    const fName = chalk__default.default.blue(codemod.format());
+    const fUID = codemodUID(codemod.uid);
+    return [fIndex, fVersion, fKind, fName, fUID];
+  });
+  const table = new CliTable3__default.default({
+    style: { compact: true },
+    head: [
+      chalk__default.default.bold.grey("N°"),
+      chalk__default.default.bold.magenta("Version"),
+      chalk__default.default.bold.yellow("Kind"),
+      chalk__default.default.bold.blue("Name"),
+      chalk__default.default.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$f = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  codemodList,
+  codemodUID,
+  durationMs,
+  highlight,
+  path,
+  projectDetails,
+  projectType,
+  reports,
+  transform,
+  upgradeStep,
+  version,
+  versionRange
+}, Symbol.toStringTag, { value: "Module" }));
+const NPM_REGISTRY_URL = "https://registry.npmjs.org";
 var ReleaseType = /* @__PURE__ */ ((ReleaseType2) => {
   ReleaseType2["Major"] = "major";
   ReleaseType2["Minor"] = "minor";
   ReleaseType2["Patch"] = "patch";
+  ReleaseType2["Latest"] = "latest";
   return ReleaseType2;
 })(ReleaseType || {});
 const types = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
@@ -237,17 +171,20 @@ const rangeFactory = (range) => {
 };
 const rangeFromReleaseType = (current, identifier) => {
   switch (identifier) {
-    case ReleaseType.Major: {
-      const nextMajor = semver__default.default.inc(current, "major");
-      return rangeFactory(`>${current.raw} <=${nextMajor}`);
+    case ReleaseType.Latest: {
+      return rangeFactory(`>${current.raw}`);
     }
-    case ReleaseType.Patch: {
-      const minor = semver__default.default.inc(current, "minor");
-      return rangeFactory(`>${current.raw} <${minor}`);
+    case ReleaseType.Major: {
+      const nextMajor = semVerFactory(current.raw).inc("major");
+      return rangeFactory(`>${current.raw} <=${nextMajor.major}`);
     }
     case ReleaseType.Minor: {
-      const major = semver__default.default.inc(current, "major");
-      return rangeFactory(`>${current.raw} <${major}`);
+      const nextMajor = semVerFactory(current.raw).inc("major");
+      return rangeFactory(`>${current.raw} <${nextMajor.raw}`);
+    }
+    case ReleaseType.Patch: {
+      const nextMinor = semVerFactory(current.raw).inc("minor");
+      return rangeFactory(`>${current.raw} <${nextMinor.raw}`);
     }
     default: {
       throw new Error("Not implemented");
@@ -263,25 +200,75 @@ const rangeFromVersions = (currentVersion, target) => {
   }
   throw new Error(`Invalid target set: ${target}`);
 };
+const isValidStringifiedRange = (str) => semver__default.default.validRange(str) !== null;
+const isRangeInstance = (range) => {
+  return range instanceof semver__default.default.Range;
+};
 const index$e = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
   Version: types,
   isLiteralSemVer,
+  isRangeInstance,
   isSemVerReleaseType,
   isSemverInstance,
   isValidSemVer,
+  isValidStringifiedRange,
   rangeFactory,
   rangeFromReleaseType,
   rangeFromVersions,
   semVerFactory
 }, Symbol.toStringTag, { value: "Module" }));
+class Package {
+  name;
+  packageURL;
+  npmPackage;
+  constructor(name) {
+    this.name = name;
+    this.packageURL = `${NPM_REGISTRY_URL}/${name}`;
+    this.npmPackage = null;
+  }
+  get isLoaded() {
+    return this.npmPackage !== null;
+  }
+  assertPackageIsLoaded(npmPackage) {
+    assert__default.default(this.isLoaded, "The package is not loaded yet");
+  }
+  getVersionsDict() {
+    this.assertPackageIsLoaded(this.npmPackage);
+    return this.npmPackage.versions;
+  }
+  getVersionsAsList() {
+    this.assertPackageIsLoaded(this.npmPackage);
+    return Object.values(this.npmPackage.versions);
+  }
+  findVersionsInRange(range) {
+    const versions = this.getVersionsAsList();
+    return versions.filter((v) => range.test(v.version)).filter((v) => isLiteralSemVer(v.version)).sort((v1, v2) => semver__default.default.compare(v1.version, v2.version));
+  }
+  findVersion(version2) {
+    const versions = this.getVersionsAsList();
+    return versions.find((npmVersion) => semver__default.default.eq(npmVersion.version, version2));
+  }
+  async refresh() {
+    const response = await fetch(this.packageURL);
+    assert__default.default(response.ok, `Request failed for ${this.packageURL}`);
+    this.npmPackage = await response.json();
+    return this;
+  }
+  versionExists(version2) {
+    return this.findVersion(version2) !== void 0;
+  }
+}
+const npmPackageFactory = (name) => new Package(name);
 class FileScanner {
   cwd;
   constructor(cwd) {
     this.cwd = cwd;
   }
   scan(patterns) {
-    const filenames = glob.glob.sync(patterns, { cwd: this.cwd });
+    const filenames = fastglob__default.default.sync(patterns, {
+      cwd: this.cwd
+    });
     return filenames.map((filename) => path__default.default.join(this.cwd, filename));
   }
 }
@@ -319,6 +306,46 @@ const index$c = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.definePrope
   __proto__: null,
   codeRunnerFactory
 }, Symbol.toStringTag, { value: "Module" }));
+class JSONTransformAPI {
+  json;
+  constructor(json) {
+    this.json = fp.cloneDeep(json);
+  }
+  get(path2, defaultValue) {
+    if (!path2) {
+      return this.root();
+    }
+    return fp.cloneDeep(fp.get(path2, this.json) ?? defaultValue);
+  }
+  has(path2) {
+    return fp.has(path2, this.json);
+  }
+  merge(other) {
+    this.json = fp.merge(other, this.json);
+    return this;
+  }
+  root() {
+    return fp.cloneDeep(this.json);
+  }
+  set(path2, value) {
+    this.json = fp.set(path2, value, this.json);
+    return this;
+  }
+  remove(path2) {
+    this.json = fp.omit(path2, this.json);
+    return this;
+  }
+}
+const createJSONTransformAPI = (object) => new JSONTransformAPI(object);
+const readJSON = async (path2) => {
+  const buffer = await fse__default.default.readFile(path2);
+  return JSON.parse(buffer.toString());
+};
+const saveJSON = async (path2, json) => {
+  const jsonAsString = `${JSON.stringify(json, null, 2)}
+`;
+  await fse__default.default.writeFile(path2, jsonAsString);
+};
 const transformJSON = async (codemodPath, paths, config) => {
   const { dry } = config;
   const startTime = process.hrtime();
@@ -330,7 +357,11 @@ const transformJSON = async (codemodPath, paths, config) => {
     timeElapsed: "",
     stats: {}
   };
-  const esbuildOptions = { extensions: [".js", ".mjs", ".ts"] };
+  const esbuildOptions = {
+    extensions: [".js", ".mjs", ".ts"],
+    hookIgnoreNodeModules: false,
+    hookMatcher: fp.isEqual(codemodPath)
+  };
   const { unregister } = node.register(esbuildOptions);
   const module2 = require(codemodPath);
   unregister();
@@ -375,17 +406,31 @@ 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_EXTENSIONS = ["js", "ts", "json"];
-const PROJECT_DEFAULT_PATTERNS = ["package.json"];
+const PROJECT_APP_ALLOWED_ROOT_PATHS = ["src", "config", "public"];
+const PROJECT_PLUGIN_ALLOWED_ROOT_PATHS = ["admin", "server"];
+const PROJECT_PLUGIN_ROOT_FILES = ["strapi-admin.js", "strapi-server.js"];
+const PROJECT_CODE_EXTENSIONS = [
+  // Source files
+  "js",
+  "mjs",
+  "ts",
+  // React files
+  "jsx",
+  "tsx"
+];
+const PROJECT_JSON_EXTENSIONS = ["json"];
+const PROJECT_ALLOWED_EXTENSIONS = [...PROJECT_CODE_EXTENSIONS, ...PROJECT_JSON_EXTENSIONS];
 const SCOPED_STRAPI_PACKAGE_PREFIX = "@strapi/";
 const STRAPI_DEPENDENCY_NAME = `${SCOPED_STRAPI_PACKAGE_PREFIX}strapi`;
 const constants$3 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  PROJECT_DEFAULT_ALLOWED_EXTENSIONS,
-  PROJECT_DEFAULT_ALLOWED_ROOT_PATHS,
-  PROJECT_DEFAULT_PATTERNS,
+  PROJECT_ALLOWED_EXTENSIONS,
+  PROJECT_APP_ALLOWED_ROOT_PATHS,
+  PROJECT_CODE_EXTENSIONS,
+  PROJECT_JSON_EXTENSIONS,
   PROJECT_PACKAGE_JSON,
+  PROJECT_PLUGIN_ALLOWED_ROOT_PATHS,
+  PROJECT_PLUGIN_ROOT_FILES,
   SCOPED_STRAPI_PACKAGE_PREFIX,
   STRAPI_DEPENDENCY_NAME
 }, Symbol.toStringTag, { value: "Module" }));
@@ -395,12 +440,13 @@ class Project {
   files;
   packageJSONPath;
   packageJSON;
-  strapiVersion;
-  constructor(cwd) {
+  paths;
+  constructor(cwd, config) {
     if (!fse__default.default.pathExistsSync(cwd)) {
       throw new Error(`ENOENT: no such file or directory, access '${cwd}'`);
     }
     this.cwd = cwd;
+    this.paths = config.paths;
     this.refresh();
   }
   getFilesByExtensions(extensions) {
@@ -411,14 +457,13 @@ class Project {
   }
   refresh() {
     this.refreshPackageJSON();
-    this.refreshStrapiVersion();
     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);
@@ -429,17 +474,20 @@ class Project {
     return reports2;
   }
   createProjectCodemodsRunners(dry = false) {
-    const jsonFiles = this.getFilesByExtensions([".json"]);
-    const codeFiles = this.getFilesByExtensions([".js", ".ts", ".mjs"]);
+    const jsonExtensions = PROJECT_JSON_EXTENSIONS.map((ext) => `.${ext}`);
+    const codeExtensions = PROJECT_CODE_EXTENSIONS.map((ext) => `.${ext}`);
+    const jsonFiles = this.getFilesByExtensions(jsonExtensions);
+    const codeFiles = this.getFilesByExtensions(codeExtensions);
     const codeRunner = codeRunnerFactory(codeFiles, {
       dry,
-      print: false,
-      silent: true,
-      extensions: "js,ts",
+      parser: "ts",
       runInBand: true,
-      verbose: 0,
       babel: true,
-      parser: "ts"
+      extensions: PROJECT_CODE_EXTENSIONS.join(","),
+      // Don't output any log coming from the runner
+      print: false,
+      silent: true,
+      verbose: 0
     });
     const jsonRunner = jsonRunnerFactory(jsonFiles, { dry, cwd: this.cwd });
     return [codeRunner, jsonRunner];
@@ -456,16 +504,38 @@ class Project {
     this.packageJSON = JSON.parse(packageJSONBuffer.toString());
   }
   refreshProjectFiles() {
-    const allowedRootPaths = formatGlobCollectionPattern(
-      PROJECT_DEFAULT_ALLOWED_ROOT_PATHS
-    );
-    const allowedExtensions = formatGlobCollectionPattern(
-      PROJECT_DEFAULT_ALLOWED_EXTENSIONS
-    );
-    const projectFilesPattern = `./${allowedRootPaths}/**/*.${allowedExtensions}`;
-    const patterns = [projectFilesPattern, ...PROJECT_DEFAULT_PATTERNS];
     const scanner = fileScannerFactory(this.cwd);
-    this.files = scanner.scan(patterns);
+    this.files = scanner.scan(this.paths);
+  }
+}
+class AppProject extends Project {
+  strapiVersion;
+  type = "application";
+  /**
+   * Returns an array of allowed file paths for a Strapi application
+   *
+   * The resulting paths include app default files and the root package.json file.
+   */
+  static get paths() {
+    const allowedRootPaths = formatGlobCollectionPattern(PROJECT_APP_ALLOWED_ROOT_PATHS);
+    const allowedExtensions = formatGlobCollectionPattern(PROJECT_ALLOWED_EXTENSIONS);
+    return [
+      // App default files
+      `./${allowedRootPaths}/**/*.${allowedExtensions}`,
+      `!./**/node_modules/**/*`,
+      `!./**/dist/**/*`,
+      // Root package.json file
+      PROJECT_PACKAGE_JSON
+    ];
+  }
+  constructor(cwd) {
+    super(cwd, { paths: AppProject.paths });
+    this.refreshStrapiVersion();
+  }
+  refresh() {
+    super.refresh();
+    this.refreshStrapiVersion();
+    return this;
   }
   refreshStrapiVersion() {
     this.strapiVersion = // First try to get the strapi version from the package.json dependencies
@@ -512,10 +582,71 @@ const formatGlobCollectionPattern = (collection) => {
   );
   return collection.length === 1 ? collection[0] : `{${collection}}`;
 };
-const projectFactory = (cwd) => new Project(cwd);
+class PluginProject extends Project {
+  type = "plugin";
+  /**
+   * Returns an array of allowed file paths for a Strapi plugin
+   *
+   * The resulting paths include plugin default files, the root package.json file, and plugin-specific files.
+   */
+  static get paths() {
+    const allowedRootPaths = formatGlobCollectionPattern(
+      PROJECT_PLUGIN_ALLOWED_ROOT_PATHS
+    );
+    const allowedExtensions = formatGlobCollectionPattern(PROJECT_ALLOWED_EXTENSIONS);
+    return [
+      // Plugin default files
+      `./${allowedRootPaths}/**/*.${allowedExtensions}`,
+      `!./**/node_modules/**/*`,
+      `!./**/dist/**/*`,
+      // Root package.json file
+      PROJECT_PACKAGE_JSON,
+      // Plugin root files
+      ...PROJECT_PLUGIN_ROOT_FILES
+    ];
+  }
+  constructor(cwd) {
+    super(cwd, { paths: PluginProject.paths });
+  }
+}
+const isPlugin = (cwd) => {
+  const packageJSONPath = path__default.default.join(cwd, PROJECT_PACKAGE_JSON);
+  try {
+    fse__default.default.accessSync(packageJSONPath);
+  } catch {
+    throw new Error(`Could not find a ${PROJECT_PACKAGE_JSON} file in ${cwd}`);
+  }
+  const packageJSONBuffer = fse__default.default.readFileSync(packageJSONPath);
+  const packageJSON = JSON.parse(packageJSONBuffer.toString());
+  return packageJSON?.strapi?.kind === "plugin";
+};
+const projectFactory = (cwd) => {
+  fse__default.default.accessSync(cwd);
+  return isPlugin(cwd) ? new PluginProject(cwd) : new AppProject(cwd);
+};
+const isPluginProject = (project) => {
+  return project instanceof PluginProject;
+};
+function assertPluginProject(project) {
+  if (!isPluginProject(project)) {
+    throw new Error("Project is not a plugin");
+  }
+}
+const isApplicationProject = (project) => {
+  return project instanceof AppProject;
+};
+function assertAppProject(project) {
+  if (!isApplicationProject(project)) {
+    throw new Error("Project is not an application");
+  }
+}
 const index$a = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
+  assertAppProject,
+  assertPluginProject,
   constants: constants$3,
+  isApplicationProject,
+  isPluginProject,
   projectFactory
 }, Symbol.toStringTag, { value: "Module" }));
 class UnexpectedError extends Error {
@@ -523,70 +654,33 @@ class UnexpectedError extends Error {
     super("Unexpected Error");
   }
 }
-const unknownToError = (e) => {
-  if (e instanceof Error) {
-    return e;
+class NPMCandidateNotFoundError extends Error {
+  target;
+  constructor(target, message = `Couldn't find a valid NPM candidate for "${target}"`) {
+    super(message);
+    this.target = target;
   }
-  if (typeof e === "string") {
-    return new Error(e);
+}
+class AbortedError extends Error {
+  constructor(message = "Upgrade aborted") {
+    super(message);
   }
-  return new UnexpectedError();
-};
-const index$9 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
-  __proto__: null,
-  UnexpectedError,
-  unknownToError
-}, Symbol.toStringTag, { value: "Module" }));
-const path = (path2) => chalk__default.default.blue(path2);
-const version = (version2) => {
-  return chalk__default.default.italic.yellow(`v${version2}`);
-};
-const versionRange = (range) => chalk__default.default.italic.yellow(range);
-const transform = (transformFilePath) => chalk__default.default.cyan(transformFilePath);
-const highlight = (arg) => chalk__default.default.bold.underline(arg);
-const upgradeStep = (text, step) => {
-  return chalk__default.default.bold(`(${step[0]}/${step[1]}) ${text}...`);
-};
-const reports = (reports2) => {
-  const rows = reports2.map(({ codemod, report }, i) => {
-    const fIndex = chalk__default.default.grey(i);
-    const fVersion = chalk__default.default.magenta(codemod.version);
-    const fKind = chalk__default.default.yellow(codemod.kind);
-    const fFormattedTransformPath = chalk__default.default.cyan(codemod.format());
-    const fTimeElapsed = i === 0 ? `${report.timeElapsed}s ${chalk__default.default.dim.italic("(cold start)")}` : `${report.timeElapsed}s`;
-    const fAffected = report.ok > 0 ? chalk__default.default.green(report.ok) : chalk__default.default.grey(0);
-    const fUnchanged = report.ok === 0 ? chalk__default.default.red(report.nochange) : chalk__default.default.grey(report.nochange);
-    return [fIndex, fVersion, fKind, fFormattedTransformPath, fAffected, fUnchanged, fTimeElapsed];
-  });
-  const table = new CliTable3__default.default({
-    style: { compact: true },
-    head: [
-      chalk__default.default.bold.grey("N°"),
-      chalk__default.default.bold.magenta("Version"),
-      chalk__default.default.bold.yellow("Kind"),
-      chalk__default.default.bold.cyan("Name"),
-      chalk__default.default.bold.green("Affected"),
-      chalk__default.default.bold.red("Unchanged"),
-      chalk__default.default.bold.blue("Duration")
-    ]
-  });
-  table.push(...rows);
-  return table.toString();
-};
-const durationMs = (elapsedMs) => {
-  const elapsedSeconds = (elapsedMs / ONE_SECOND_MS).toFixed(3);
-  return `${elapsedSeconds}s`;
+}
+const unknownToError = (e) => {
+  if (e instanceof Error) {
+    return e;
+  }
+  if (typeof e === "string") {
+    return new Error(e);
+  }
+  return new UnexpectedError();
 };
-const index$8 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+const index$9 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  durationMs,
-  highlight,
-  path,
-  reports,
-  transform,
-  upgradeStep,
-  version,
-  versionRange
+  AbortedError,
+  NPMCandidateNotFoundError,
+  UnexpectedError,
+  unknownToError
 }, Symbol.toStringTag, { value: "Module" }));
 const CODEMOD_CODE_SUFFIX = "code";
 const CODEMOD_JSON_SUFFIX = "json";
@@ -604,6 +698,7 @@ const constants$2 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineP
   CODEMOD_JSON_SUFFIX
 }, Symbol.toStringTag, { value: "Module" }));
 class Codemod {
+  uid;
   kind;
   version;
   baseDirectory;
@@ -615,17 +710,49 @@ class Codemod {
     this.baseDirectory = options.baseDirectory;
     this.filename = options.filename;
     this.path = path__default.default.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);
-const index$7 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+const index$8 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
   codemodFactory,
   constants: constants$2
 }, Symbol.toStringTag, { value: "Module" }));
+const INTERNAL_CODEMODS_DIRECTORY = path__default.default.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;
@@ -644,23 +771,48 @@ 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, codemods]) => ({
+      version: semVerFactory(version2),
+      codemods
+    }));
   }
   refreshAvailableVersions() {
     this.versions = fse__default.default.readdirSync(this.cwd).filter((filename) => fse__default.default.statSync(path__default.default.join(this.cwd, filename)).isDirectory()).filter((filename) => semver__default.default.valid(filename) !== null).map((version2) => semVerFactory(version2)).sort(semver__default.default.compare);
@@ -691,19 +843,10 @@ const parseCodemodKindFromFilename = (filename) => {
   assert__default.default(CODEMOD_ALLOWED_SUFFIXES.includes(kind));
   return kind;
 };
-const codemodRepositoryFactory = (cwd) => new CodemodRepository(cwd);
-const INTERNAL_CODEMODS_DIRECTORY = path__default.default.join(
-  __dirname,
-  "..",
-  "..",
-  "resources",
-  "codemods"
-);
-const constants$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
-  __proto__: null,
-  INTERNAL_CODEMODS_DIRECTORY
-}, Symbol.toStringTag, { value: "Module" }));
-const index$6 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+const codemodRepositoryFactory = (cwd = INTERNAL_CODEMODS_DIRECTORY) => {
+  return new CodemodRepository(cwd);
+};
+const index$7 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
   codemodRepositoryFactory,
   constants: constants$1
@@ -737,34 +880,59 @@ class CodemodRunner {
     this.isDry = enabled;
     return this;
   }
-  async run(codemodsDirectory) {
+  createRepository(codemodsDirectory) {
     const repository = codemodRepositoryFactory(
       codemodsDirectory ?? INTERNAL_CODEMODS_DIRECTORY
     );
     repository.refresh();
-    const allVersionedCodemods = repository.findByRange(this.range);
-    const versionedCodemods = this.selectCodemodsCallback ? await this.selectCodemodsCallback(allVersionedCodemods) : allVersionedCodemods;
-    const hasCodemodsToRun = versionedCodemods.length > 0;
-    if (!hasCodemodsToRun) {
-      this.logger?.debug(`Found no codemods to run for ${versionRange(this.range)}`);
-      return successReport$1();
+    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."
+      );
     }
-    this.logger?.debug(
-      `Found codemods for ${highlight(
-        versionedCodemods.length
-      )} version(s) using ${versionRange(this.range)}`
-    );
-    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 = fp.groupBy("version", codemods);
+    const fRange = versionRange(this.range);
+    this.logger?.debug?.(
+      `Found ${highlight(codemods.length)} codemods for ${highlight(fp.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) => {
@@ -791,6 +959,15 @@ class Upgrader {
     this.logger = null;
     this.confirmationCallback = null;
   }
+  getNPMPackage() {
+    return this.npmPackage;
+  }
+  getProject() {
+    return this.project;
+  }
+  getTarget() {
+    return semVerFactory(this.target.raw);
+  }
   setRequirements(requirements) {
     this.requirements = requirements;
     return this;
@@ -803,7 +980,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
       )}`
@@ -812,7 +989,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;
@@ -832,44 +1009,52 @@ 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?.info(upgradeStep("Upgrading Strapi dependencies", [3, 4]));
+      this.logger?.debug?.("Refreshing project information...");
+      this.project.refresh();
+      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));
     }
     return successReport();
   }
+  async confirm(message) {
+    if (typeof this.confirmationCallback !== "function") {
+      return true;
+    }
+    return this.confirmationCallback(message);
+  }
   async checkRequirements(requirements, context) {
     for (const requirement of requirements) {
       const { pass, error } = await requirement.test(context);
@@ -896,7 +1081,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;
@@ -907,9 +1092,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;
@@ -917,7 +1104,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__default.default.italic("dry mode")})`);
+      this.logger?.debug?.(`Skipping dependencies update (${chalk__default.default.italic("dry mode")})`);
       return;
     }
     await saveJSON(packageJSONPath, updatedPackageJSON);
@@ -937,9 +1124,9 @@ class Upgrader {
   async installDependencies() {
     const projectPath = this.project.cwd;
     const packageManagerName = await utils.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__default.default.italic("dry mode")}`);
+      this.logger?.debug?.(`Skipping dependencies installation (${chalk__default.default.italic("dry mode")})`);
       return;
     }
     await utils.packageManager.installDependencies(projectPath, packageManagerName, {
@@ -958,23 +1145,28 @@ class Upgrader {
 }
 const resolveNPMTarget = (project, target, npmPackage) => {
   if (isSemverInstance(target)) {
-    return npmPackage.findVersion(target);
+    const version2 = npmPackage.findVersion(target);
+    if (!version2) {
+      throw new NPMCandidateNotFoundError(target);
+    }
+    return version2;
   }
   if (isSemVerReleaseType(target)) {
     const range = rangeFromVersions(project.strapiVersion, target);
     const npmVersionsMatches = npmPackage.findVersionsInRange(range);
-    return npmVersionsMatches.at(-1);
+    const version2 = npmVersionsMatches.at(-1);
+    if (!version2) {
+      throw new NPMCandidateNotFoundError(range, `The project is already up-to-date (${target})`);
+    }
+    return version2;
   }
-  return void 0;
+  throw new NPMCandidateNotFoundError(target);
 };
 const upgraderFactory = (project, target, npmPackage) => {
-  const targetedNPMVersion = resolveNPMTarget(project, target, npmPackage);
-  if (!targetedNPMVersion) {
-    throw new Error(`Couldn't find a matching version in the NPM registry for "${target}"`);
-  }
-  const semverTarget = semVerFactory(targetedNPMVersion.version);
+  const npmTarget = resolveNPMTarget(project, target, npmPackage);
+  const semverTarget = semVerFactory(npmTarget.version);
   if (semver__default.default.eq(semverTarget, project.strapiVersion)) {
-    throw new Error(`The project is already on ${version(semverTarget)}`);
+    throw new Error(`The project is already using v${semverTarget}`);
   }
   return new Upgrader(project, semverTarget, npmPackage);
 };
@@ -985,96 +1177,205 @@ const constants = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.definePro
   __proto__: null,
   STRAPI_PACKAGE_NAME
 }, Symbol.toStringTag, { value: "Module" }));
-const index$5 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+const index$6 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
   constants,
   upgraderFactory
 }, Symbol.toStringTag, { value: "Module" }));
-const NPM_REGISTRY_URL = "https://registry.npmjs.org";
-class Package {
+class Requirement {
+  isRequired;
   name;
-  packageURL;
-  npmPackage;
-  constructor(name) {
+  testCallback;
+  children;
+  constructor(name, testCallback, isRequired) {
     this.name = name;
-    this.packageURL = `${NPM_REGISTRY_URL}/${name}`;
-    this.npmPackage = null;
+    this.testCallback = testCallback;
+    this.isRequired = isRequired ?? true;
+    this.children = [];
   }
-  get isLoaded() {
-    return this.npmPackage !== null;
+  setChildren(children) {
+    this.children = children;
+    return this;
   }
-  assertPackageIsLoaded(npmPackage) {
-    assert__default.default(this.isLoaded, "The package is not loaded yet");
+  addChild(child) {
+    this.children.push(child);
+    return this;
   }
-  getVersionsDict() {
-    this.assertPackageIsLoaded(this.npmPackage);
-    return this.npmPackage.versions;
+  asOptional() {
+    const newInstance = requirementFactory(this.name, this.testCallback, false);
+    newInstance.setChildren(this.children);
+    return newInstance;
   }
-  getVersionsAsList() {
-    this.assertPackageIsLoaded(this.npmPackage);
-    return Object.values(this.npmPackage.versions);
+  asRequired() {
+    const newInstance = requirementFactory(this.name, this.testCallback, true);
+    newInstance.setChildren(this.children);
+    return newInstance;
   }
-  findVersionsInRange(range) {
-    const versions = this.getVersionsAsList();
-    return versions.filter((v) => range.test(v.version)).filter((v) => isLiteralSemVer(v.version)).sort((v1, v2) => semver__default.default.compare(v1.version, v2.version));
+  async test(context) {
+    try {
+      await this.testCallback?.(context);
+      return ok();
+    } catch (e) {
+      if (e instanceof Error) {
+        return errored(e);
+      }
+      if (typeof e === "string") {
+        return errored(new Error(e));
+      }
+      return errored(new Error("Unknown error"));
+    }
   }
-  findVersion(version2) {
-    const versions = this.getVersionsAsList();
-    return versions.find((npmVersion) => semver__default.default.eq(npmVersion.version, version2));
+}
+const ok = () => ({ pass: true, error: null });
+const errored = (error) => ({ pass: false, error });
+const requirementFactory = (name, testCallback, isRequired) => new Requirement(name, testCallback, isRequired);
+const index$5 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  requirementFactory
+}, Symbol.toStringTag, { value: "Module" }));
+const REQUIRE_AVAILABLE_NEXT_MAJOR = requirementFactory(
+  "REQUIRE_AVAILABLE_NEXT_MAJOR",
+  (context) => {
+    const { project, target } = context;
+    const currentMajor = project.strapiVersion.major;
+    const targetedMajor = target.major;
+    if (targetedMajor === currentMajor) {
+      throw new Error(`You're already on the latest major version (v${currentMajor})`);
+    }
   }
-  async refresh() {
-    const response = await fetch(this.packageURL);
-    assert__default.default(response.ok, `Request failed for ${this.packageURL}`);
-    this.npmPackage = await response.json();
-    return this;
+);
+const REQUIRE_LATEST_FOR_CURRENT_MAJOR = requirementFactory(
+  "REQUIRE_LATEST_FOR_CURRENT_MAJOR",
+  (context) => {
+    const { project, target, npmVersionsMatches } = context;
+    const { major: currentMajor } = project.strapiVersion;
+    const invalidMatches = npmVersionsMatches.filter(
+      (match) => semVerFactory(match.version).major === currentMajor
+    );
+    if (invalidMatches.length > 0) {
+      const invalidVersions = invalidMatches.map((match) => match.version);
+      const invalidVersionsCount = invalidVersions.length;
+      throw new Error(
+        `Doing a major upgrade requires to be on the latest v${currentMajor} version, but found ${invalidVersionsCount} versions between the current one and ${target}. Please upgrade to ${invalidVersions.at(-1)} and try again.`
+      );
+    }
   }
-  versionExists(version2) {
-    return this.findVersion(version2) !== void 0;
+);
+const REQUIRE_GIT_CLEAN_REPOSITORY = requirementFactory(
+  "REQUIRE_GIT_CLEAN_REPOSITORY",
+  async (context) => {
+    const git = simpleGit__default.default({ baseDir: context.project.cwd });
+    const status = await git.status();
+    if (!status.isClean()) {
+      throw new Error(
+        "Repository is not clean. Please commit or stash any changes before upgrading"
+      );
+    }
   }
-}
-const npmPackageFactory = (name) => new Package(name);
+);
+const REQUIRE_GIT_REPOSITORY = requirementFactory(
+  "REQUIRE_GIT_REPOSITORY",
+  async (context) => {
+    const git = simpleGit__default.default({ baseDir: context.project.cwd });
+    const isRepo = await git.checkIsRepo();
+    if (!isRepo) {
+      throw new Error("Not a git repository (or any of the parent directories)");
+    }
+  }
+).addChild(REQUIRE_GIT_CLEAN_REPOSITORY.asOptional());
+const REQUIRE_GIT_INSTALLED = requirementFactory(
+  "REQUIRE_GIT_INSTALLED",
+  async (context) => {
+    const git = simpleGit__default.default({ baseDir: context.project.cwd });
+    try {
+      await git.version();
+    } catch {
+      throw new Error("Git is not installed");
+    }
+  }
+).addChild(REQUIRE_GIT_REPOSITORY.asOptional());
+const REQUIRE_GIT = requirementFactory("REQUIRE_GIT", null).addChild(
+  REQUIRE_GIT_INSTALLED.asOptional()
+);
+const latest = async (upgrader, options) => {
+  if (options.target !== ReleaseType.Latest) {
+    return;
+  }
+  const npmPackage = upgrader.getNPMPackage();
+  const target = upgrader.getTarget();
+  const project = upgrader.getProject();
+  const { strapiVersion: current } = project;
+  const fTargetMajor = highlight(`v${target.major}`);
+  const fCurrentMajor = highlight(`v${current.major}`);
+  const fTarget = version(target);
+  const fCurrent = version(current);
+  const isMajorUpgrade = target.major > current.major;
+  if (isMajorUpgrade) {
+    options.logger.warn(
+      `Detected a major upgrade for the "${highlight(ReleaseType.Latest)}" tag: ${fCurrent} > ${fTarget}`
+    );
+    const newerPackageRelease = npmPackage.findVersionsInRange(rangeFactory(`>${current.raw} <${target.major}`)).at(-1);
+    if (newerPackageRelease) {
+      const fLatest = version(semVerFactory(newerPackageRelease.version));
+      options.logger.warn(
+        `It's recommended to first upgrade to the latest version of ${fCurrentMajor} (${fLatest}) before upgrading to ${fTargetMajor}.`
+      );
+    }
+    const proceedAnyway = await upgrader.confirm(`I know what I'm doing. Proceed anyway!`);
+    if (!proceedAnyway) {
+      throw new AbortedError();
+    }
+  }
+};
 const upgrade = async (options) => {
   const timer = timerFactory();
   const { logger, codemodsTarget } = options;
   const cwd = path__default.default.resolve(options.cwd ?? process.cwd());
   const project = projectFactory(cwd);
+  logger.debug(projectDetails(project));
+  if (!isApplicationProject(project)) {
+    throw new Error(
+      `The "${options.target}" upgrade can only be run on a Strapi project; for plugins, please use "codemods".`
+    );
+  }
+  logger.debug(
+    `Application: VERSION=${version(project.packageJSON.version)}; STRAPI_VERSION=${version(project.strapiVersion)}`
+  );
   const npmPackage = npmPackageFactory(STRAPI_PACKAGE_NAME);
   await npmPackage.refresh();
   const upgrader = upgraderFactory(project, options.target, npmPackage).dry(options.dry ?? false).onConfirm(options.confirm ?? null).setLogger(logger);
   if (codemodsTarget !== void 0) {
     upgrader.overrideCodemodsTarget(codemodsTarget);
   }
-  if (options.target === ReleaseType.Major) {
-    upgrader.addRequirement(REQUIRE_AVAILABLE_NEXT_MAJOR).addRequirement(REQUIRE_LATEST_FOR_CURRENT_MAJOR);
-  }
-  upgrader.addRequirement(REQUIRE_GIT.asOptional());
+  await runUpgradePrompts(upgrader, options);
+  addUpgradeRequirements(upgrader, options);
   const upgradeReport = await upgrader.upgrade();
   if (!upgradeReport.success) {
     throw upgradeReport.error;
   }
   timer.stop();
-  logger.info(`Completed in ${durationMs(timer.elapsedMs)}`);
+  logger.info(`Completed in ${durationMs(timer.elapsedMs)}ms`);
 };
-const codemods = async (options) => {
-  const timer = timerFactory();
-  const { logger } = options;
-  const cwd = path__default.default.resolve(options.cwd ?? process.cwd());
-  const project = projectFactory(cwd);
-  const range = getRangeFromTarget(project.strapiVersion, options.target);
-  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;
+const runUpgradePrompts = async (upgrader, options) => {
+  if (options.target === ReleaseType.Latest) {
+    await latest(upgrader, options);
   }
-  timer.stop();
-  logger.info(`Completed in ${timer.elapsedMs}`);
 };
+const addUpgradeRequirements = (upgrader, options) => {
+  if (options.target === ReleaseType.Major) {
+    upgrader.addRequirement(REQUIRE_AVAILABLE_NEXT_MAJOR).addRequirement(REQUIRE_LATEST_FOR_CURRENT_MAJOR);
+  }
+  upgrader.addRequirement(REQUIRE_GIT.asOptional());
+};
+const resolvePath = (cwd) => path__default.default.resolve(cwd ?? process.cwd());
 const getRangeFromTarget = (currentVersion, target) => {
   if (isSemverInstance(target)) {
     return rangeFactory(target);
   }
   const { major, minor, patch } = currentVersion;
   switch (target) {
+    case ReleaseType.Latest:
+      throw new Error("Can't use <latest> to create a codemods range: not implemented");
     case ReleaseType.Major:
       return rangeFactory(`${major}`);
     case ReleaseType.Minor:
@@ -1085,9 +1386,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(projectDetails(project));
+  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(projectDetails(project));
+  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 {
@@ -1181,18 +1533,18 @@ const index$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.definePrope
 }, Symbol.toStringTag, { value: "Module" }));
 const index = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  codemod: index$7,
-  codemodRepository: index$6,
+  codemod: index$8,
+  codemodRepository: index$7,
   error: index$9,
-  f: index$8,
+  f: index$f,
   fileScanner: index$d,
   logger: index$3,
   project: index$a,
   report: index$2,
-  requirement: index$g,
+  requirement: index$5,
   runner: index$1,
-  timer: index$f,
-  upgrader: index$5,
+  timer: index$g,
+  upgrader: index$6,
   version: index$e
 }, Symbol.toStringTag, { value: "Module" }));
 exports.modules = index;