@strapi/upgrade 5.9.0 → 5.10.1

package/dist/chunks/logger-DGi224NW.js

@@ -0,0 +1,1649 @@
+'use strict';
+
+var path$1 = require('node:path');
+var assert = require('node:assert');
+var semver = require('semver');
+var chalk = require('chalk');
+var utils = require('@strapi/utils');
+var fse = require('fs-extra');
+var fastglob = require('fast-glob');
+var Runner = require('jscodeshift/src/Runner');
+var fp = require('lodash/fp');
+var node = require('esbuild-register/dist/node');
+var simpleGit = require('simple-git');
+var CliTable3 = require('cli-table3');
+
+class Timer {
+    get elapsedMs() {
+        const { start, end } = this.interval;
+        return end ? end - start : Date.now() - start;
+    }
+    get end() {
+        return this.interval.end;
+    }
+    get start() {
+        return this.interval.start;
+    }
+    stop() {
+        this.interval.end = Date.now();
+        return this.elapsedMs;
+    }
+    reset() {
+        this.interval = {
+            start: Date.now(),
+            end: null
+        };
+        return this;
+    }
+    constructor(){
+        this.reset();
+    }
+}
+const timerFactory = ()=>new Timer();
+
+const ONE_SECOND_MS = 1000;
+
+var constants$4 = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  ONE_SECOND_MS: ONE_SECOND_MS
+});
+
+const path = (path)=>chalk.blue(path);
+const version = (version)=>{
+    return chalk.italic.yellow(`v${version}`);
+};
+const codemodUID = (uid)=>{
+    return chalk.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.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)=>{
+    return chalk.bold(`(${step[0]}/${step[1]}) ${text}...`);
+};
+const reports = (reports)=>{
+    const rows = reports.map(({ codemod, report }, i)=>{
+        const fIndex = chalk.grey(i);
+        const fVersion = chalk.magenta(codemod.version);
+        const fKind = chalk.yellow(codemod.kind);
+        const fFormattedTransformPath = chalk.cyan(codemod.format());
+        const fTimeElapsed = i === 0 ? `${report.timeElapsed}s ${chalk.dim.italic('(cold start)')}` : `${report.timeElapsed}s`;
+        const fAffected = report.ok > 0 ? chalk.green(report.ok) : chalk.grey(0);
+        const fUnchanged = report.ok === 0 ? chalk.red(report.nochange) : chalk.grey(report.nochange);
+        return [
+            fIndex,
+            fVersion,
+            fKind,
+            fFormattedTransformPath,
+            fAffected,
+            fUnchanged,
+            fTimeElapsed
+        ];
+    });
+    const table = new CliTable3({
+        style: {
+            compact: true
+        },
+        head: [
+            chalk.bold.grey('N°'),
+            chalk.bold.magenta('Version'),
+            chalk.bold.yellow('Kind'),
+            chalk.bold.cyan('Name'),
+            chalk.bold.green('Affected'),
+            chalk.bold.red('Unchanged'),
+            chalk.bold.blue('Duration')
+        ]
+    });
+    table.push(...rows);
+    return table.toString();
+};
+const codemodList = (codemods)=>{
+    const rows = codemods.map((codemod, index)=>{
+        const fIndex = chalk.grey(index);
+        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 NPM_REGISTRY_URL = 'https://registry.npmjs.org';
+
+exports.ReleaseType = void 0;
+(function(ReleaseType) {
+    // Classic
+    ReleaseType["Major"] = "major";
+    ReleaseType["Minor"] = "minor";
+    ReleaseType["Patch"] = "patch";
+    // Other
+    ReleaseType["Latest"] = "latest";
+})(exports.ReleaseType || (exports.ReleaseType = {}));
+
+var types = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  get ReleaseType () { return exports.ReleaseType; }
+});
+
+const semVerFactory = (version)=>{
+    return new semver.SemVer(version);
+};
+const isLiteralSemVer = (str)=>{
+    const tokens = str.split('.');
+    return tokens.length === 3 && tokens.every((token)=>!Number.isNaN(+token) && Number.isInteger(+token));
+};
+const isValidSemVer = (str)=>semver.valid(str) !== null;
+const isSemverInstance = (value)=>{
+    return value instanceof semver.SemVer;
+};
+const isSemVerReleaseType = (str)=>{
+    return Object.values(exports.ReleaseType).includes(str);
+};
+
+const rangeFactory = (range)=>{
+    return new semver.Range(range);
+};
+const rangeFromReleaseType = (current, identifier)=>{
+    switch(identifier){
+        case exports.ReleaseType.Latest:
+            {
+                // Match anything greater than the current version
+                return rangeFactory(`>${current.raw}`);
+            }
+        case exports.ReleaseType.Major:
+            {
+                // For example, 4.15.4 returns 5.0.0
+                const nextMajor = semVerFactory(current.raw).inc('major');
+                // Using only the major version as the upper limit allows any minor,
+                // patch, or build version to be taken in the range.
+                //
+                // For example, if the current version is "4.15.4", incrementing the
+                // major version would result in "5.0.0".
+                // The generated rule is ">4.15.4 <=5", allowing any version
+                // greater than "4.15.4" but less than "6.0.0-0".
+                return rangeFactory(`>${current.raw} <=${nextMajor.major}`);
+            }
+        case exports.ReleaseType.Minor:
+            {
+                // For example, 4.15.4 returns 5.0.0
+                const nextMajor = semVerFactory(current.raw).inc('major');
+                // Using the <major>.<minor>.<patch> version as the upper limit allows any minor,
+                // patch, or build versions to be taken in the range.
+                //
+                // For example, if the current version is "4.15.4", incrementing the
+                // major version would result in "5.0.0".
+                // The generated rule is ">4.15.4 <5.0.0", allowing any version
+                // greater than "4.15.4" but less than "5.0.0".
+                return rangeFactory(`>${current.raw} <${nextMajor.raw}`);
+            }
+        case exports.ReleaseType.Patch:
+            {
+                // For example, 4.15.4 returns 4.16.0
+                const nextMinor = semVerFactory(current.raw).inc('minor');
+                // Using only the minor version as the upper limit allows any patch
+                // or build versions to be taken in the range.
+                //
+                // For example, if the current version is "4.15.4", incrementing the
+                // minor version would result in "4.16.0".
+                // The generated rule is ">4.15.4 <4.16.0", allowing any version
+                // greater than "4.15.4" but less than "4.16.0".
+                return rangeFactory(`>${current.raw} <${nextMinor.raw}`);
+            }
+        default:
+            {
+                throw new Error('Not implemented');
+            }
+    }
+};
+const rangeFromVersions = (currentVersion, target)=>{
+    if (isSemverInstance(target)) {
+        return rangeFactory(`>${currentVersion.raw} <=${target.raw}`);
+    }
+    if (isSemVerReleaseType(target)) {
+        return rangeFromReleaseType(currentVersion, target);
+    }
+    throw new Error(`Invalid target set: ${target}`); // TODO: better errors
+};
+const isValidStringifiedRange = (str)=>semver.validRange(str) !== null;
+const isRangeInstance = (range)=>{
+    return range instanceof semver.Range;
+};
+
+class Package {
+    get isLoaded() {
+        return this.npmPackage !== null;
+    }
+    assertPackageIsLoaded(npmPackage) {
+        assert(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// Only select versions matching the upgrade range
+        .filter((v)=>range.test(v.version))// Only select supported version format (x.x.x)
+        .filter((v)=>isLiteralSemVer(v.version))// Sort in ascending order
+        .sort((v1, v2)=>semver.compare(v1.version, v2.version));
+    }
+    findVersion(version) {
+        const versions = this.getVersionsAsList();
+        return versions.find((npmVersion)=>semver.eq(npmVersion.version, version));
+    }
+    async refresh() {
+        const response = await fetch(this.packageURL);
+        // TODO: Use a validation library to make sure the response structure is correct
+        assert(response.ok, `Request failed for ${this.packageURL}`);
+        this.npmPackage = await response.json();
+        return this;
+    }
+    versionExists(version) {
+        return this.findVersion(version) !== undefined;
+    }
+    constructor(name){
+        this.name = name;
+        this.packageURL = `${NPM_REGISTRY_URL}/${name}`;
+        this.npmPackage = null;
+    }
+}
+const npmPackageFactory = (name)=>new Package(name);
+
+class FileScanner {
+    scan(patterns) {
+        // we use fastglob instead of glob because it supports negation patterns
+        const filenames = fastglob.sync(patterns, {
+            cwd: this.cwd
+        });
+        // Resolve the full paths for every filename
+        return filenames.map((filename)=>path$1.join(this.cwd, filename));
+    }
+    constructor(cwd){
+        this.cwd = cwd;
+    }
+}
+const fileScannerFactory = (cwd)=>new FileScanner(cwd);
+
+class AbstractRunner {
+    async run(codemod, configuration) {
+        const isValidCodemod = this.valid(codemod);
+        if (!isValidCodemod) {
+            throw new Error(`Invalid codemod provided to the runner: ${codemod.filename}`);
+        }
+        const runConfiguration = {
+            ...this.configuration,
+            ...configuration
+        };
+        return this.runner(codemod.path, this.paths, runConfiguration);
+    }
+    constructor(paths, configuration){
+        this.paths = paths;
+        this.configuration = configuration;
+    }
+}
+
+class CodeRunner extends AbstractRunner {
+    valid(codemod) {
+        return codemod.kind === 'code';
+    }
+    constructor(...args){
+        super(...args);
+        this.runner = Runner.run;
+    }
+}
+const codeRunnerFactory = (paths, configuration)=>{
+    return new CodeRunner(paths, configuration);
+};
+
+class JSONTransformAPI {
+    get(path, defaultValue) {
+        if (!path) {
+            return this.root();
+        }
+        return fp.cloneDeep(fp.get(path, this.json) ?? defaultValue);
+    }
+    has(path) {
+        return fp.has(path, this.json);
+    }
+    merge(other) {
+        this.json = fp.merge(other, this.json);
+        return this;
+    }
+    root() {
+        return fp.cloneDeep(this.json);
+    }
+    set(path, value) {
+        this.json = fp.set(path, value, this.json);
+        return this;
+    }
+    remove(path) {
+        this.json = fp.omit(path, this.json);
+        return this;
+    }
+    constructor(json){
+        this.json = fp.cloneDeep(json);
+    }
+}
+const createJSONTransformAPI = (object)=>new JSONTransformAPI(object);
+
+const readJSON = async (path)=>{
+    const buffer = await fse.readFile(path);
+    return JSON.parse(buffer.toString());
+};
+const saveJSON = async (path, json)=>{
+    const jsonAsString = `${JSON.stringify(json, null, 2)}\n`;
+    await fse.writeFile(path, jsonAsString);
+};
+
+const transformJSON = async (codemodPath, paths, config)=>{
+    const { dry } = config;
+    const startTime = process.hrtime();
+    const report = {
+        ok: 0,
+        nochange: 0,
+        skip: 0,
+        error: 0,
+        timeElapsed: '',
+        stats: {}
+    };
+    /**
+   * Why do we need to include node_modules (hookIgnoreNodeModules) and specify a matcher (hookMatcher) to esbuild?
+   *
+   * When using tools like npx or dlx, the execution context is different from when running the program in a local
+   * project. npx and dlx run the commands in a temporary installation, which is isolated from local project files.
+   *
+   * When hookIgnoreNodeModules is not specified (or set to true), esbuild-register instructs
+   * Pirates (https://github.com/danez/pirates) to not transpile any files that come from node_modules.
+   *
+   * Now, when using npx or dlx to run a script, its location can be seen as "external" because it's not part of
+   * the temporary environment where npx or dlx execute. Therefore, it's considered to be part of node_modules.
+   *
+   * Due to this, if hookIgnoreNodeModules is set to true or left unspecified,
+   * esbuild-register won't try to compile them upon require.
+   *
+   * hookMatcher is added to make sure we're not matching anything else than our codemod in external directories.
+   */ const esbuildOptions = {
+        extensions: [
+            '.js',
+            '.mjs',
+            '.ts'
+        ],
+        hookIgnoreNodeModules: false,
+        hookMatcher: fp.isEqual(codemodPath)
+    };
+    const { unregister } = node.register(esbuildOptions);
+    const module = require(codemodPath);
+    unregister();
+    const codemod = typeof module.default === 'function' ? module.default : module;
+    assert(typeof codemod === 'function', `Codemod must be a function. Found ${typeof codemod}`);
+    for (const path of paths){
+        try {
+            const json = await readJSON(path);
+            // Make sure the JSON value is a JSON object
+            assert(typeof json === 'object' && !Array.isArray(json) && json !== null);
+            // TODO: Optimize the API to limit parse/stringify operations
+            const file = {
+                path,
+                json
+            };
+            const params = {
+                cwd: config.cwd,
+                json: createJSONTransformAPI
+            };
+            const out = await codemod(file, params);
+            if (out === undefined) {
+                report.error += 1;
+            } else if (!fp.isEqual(json, out)) {
+                if (!dry) {
+                    await saveJSON(path, out);
+                }
+                report.ok += 1;
+            } else {
+                report.nochange += 1;
+            }
+        } catch  {
+            report.error += 1;
+        }
+    }
+    const endTime = process.hrtime(startTime);
+    report.timeElapsed = (endTime[0] + endTime[1] / 1e9).toFixed(3);
+    return report;
+};
+
+class JSONRunner extends AbstractRunner {
+    valid(codemod) {
+        return codemod.kind === 'json';
+    }
+    constructor(...args){
+        super(...args);
+        this.runner = transformJSON;
+    }
+}
+const jsonRunnerFactory = (paths, configuration)=>{
+    return new JSONRunner(paths, configuration);
+};
+
+const PROJECT_PACKAGE_JSON = '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`;
+
+var constants$3 = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  PROJECT_ALLOWED_EXTENSIONS: PROJECT_ALLOWED_EXTENSIONS,
+  PROJECT_APP_ALLOWED_ROOT_PATHS: PROJECT_APP_ALLOWED_ROOT_PATHS,
+  PROJECT_CODE_EXTENSIONS: PROJECT_CODE_EXTENSIONS,
+  PROJECT_JSON_EXTENSIONS: PROJECT_JSON_EXTENSIONS,
+  PROJECT_PACKAGE_JSON: PROJECT_PACKAGE_JSON,
+  PROJECT_PLUGIN_ALLOWED_ROOT_PATHS: PROJECT_PLUGIN_ALLOWED_ROOT_PATHS,
+  PROJECT_PLUGIN_ROOT_FILES: PROJECT_PLUGIN_ROOT_FILES,
+  SCOPED_STRAPI_PACKAGE_PREFIX: SCOPED_STRAPI_PACKAGE_PREFIX,
+  STRAPI_DEPENDENCY_NAME: STRAPI_DEPENDENCY_NAME
+});
+
+class Project {
+    getFilesByExtensions(extensions) {
+        return this.files.filter((filePath)=>{
+            const fileExtension = path$1.extname(filePath);
+            return extensions.includes(fileExtension);
+        });
+    }
+    refresh() {
+        this.refreshPackageJSON();
+        this.refreshProjectFiles();
+        return this;
+    }
+    async runCodemods(codemods, options) {
+        const runners = this.createProjectCodemodsRunners(options.dry);
+        const reports = [];
+        for (const codemod of codemods){
+            for (const runner of runners){
+                if (runner.valid(codemod)) {
+                    const report = await runner.run(codemod);
+                    reports.push({
+                        codemod,
+                        report
+                    });
+                }
+            }
+        }
+        return reports;
+    }
+    createProjectCodemodsRunners(dry = false) {
+        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,
+            parser: 'ts',
+            runInBand: true,
+            babel: true,
+            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
+        ];
+    }
+    refreshPackageJSON() {
+        const packageJSONPath = path$1.join(this.cwd, PROJECT_PACKAGE_JSON);
+        try {
+            fse.accessSync(packageJSONPath);
+        } catch  {
+            throw new Error(`Could not find a ${PROJECT_PACKAGE_JSON} file in ${this.cwd}`);
+        }
+        const packageJSONBuffer = fse.readFileSync(packageJSONPath);
+        this.packageJSONPath = packageJSONPath;
+        this.packageJSON = JSON.parse(packageJSONBuffer.toString());
+    }
+    refreshProjectFiles() {
+        const scanner = fileScannerFactory(this.cwd);
+        this.files = scanner.scan(this.paths);
+    }
+    constructor(cwd, config){
+        if (!fse.pathExistsSync(cwd)) {
+            throw new Error(`ENOENT: no such file or directory, access '${cwd}'`);
+        }
+        this.cwd = cwd;
+        this.paths = config.paths;
+        this.refresh();
+    }
+}
+class AppProject extends Project {
+    /**
+   * 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
+        ];
+    }
+    refresh() {
+        super.refresh();
+        this.refreshStrapiVersion();
+        return this;
+    }
+    refreshStrapiVersion() {
+        this.strapiVersion = // First try to get the strapi version from the package.json dependencies
+        this.findStrapiVersionFromProjectPackageJSON() ?? // If the version found is not a valid SemVer, get the Strapi version from the installed package
+        this.findLocallyInstalledStrapiVersion();
+    }
+    findStrapiVersionFromProjectPackageJSON() {
+        const projectName = this.packageJSON.name;
+        const version = this.packageJSON.dependencies?.[STRAPI_DEPENDENCY_NAME];
+        if (version === undefined) {
+            throw new Error(`No version of ${STRAPI_DEPENDENCY_NAME} was found in ${projectName}. Are you in a valid Strapi project?`);
+        }
+        const isValidSemVer = isLiteralSemVer(version) && semver.valid(version) === version;
+        // We return undefined only if a strapi/strapi version is found, but it's not semver compliant
+        return isValidSemVer ? semVerFactory(version) : undefined;
+    }
+    findLocallyInstalledStrapiVersion() {
+        const packageSearchText = `${STRAPI_DEPENDENCY_NAME}/package.json`;
+        let strapiPackageJSONPath;
+        let strapiPackageJSON;
+        try {
+            strapiPackageJSONPath = require.resolve(packageSearchText, {
+                paths: [
+                    this.cwd
+                ]
+            });
+            strapiPackageJSON = require(strapiPackageJSONPath);
+            assert(typeof strapiPackageJSON === 'object');
+        } catch  {
+            throw new Error(`Cannot resolve module "${STRAPI_DEPENDENCY_NAME}" from paths [${this.cwd}]`);
+        }
+        const strapiVersion = strapiPackageJSON.version;
+        if (!isValidSemVer(strapiVersion)) {
+            throw new Error(`Invalid ${STRAPI_DEPENDENCY_NAME} version found in ${strapiPackageJSONPath} (${strapiVersion})`);
+        }
+        return semVerFactory(strapiVersion);
+    }
+    constructor(cwd){
+        super(cwd, {
+            paths: AppProject.paths
+        });
+        this.type = 'application';
+        this.refreshStrapiVersion();
+    }
+}
+const formatGlobCollectionPattern = (collection)=>{
+    assert(collection.length > 0, 'Invalid pattern provided, the given collection needs at least 1 element');
+    return collection.length === 1 ? collection[0] : `{${collection}}`;
+};
+class PluginProject extends Project {
+    /**
+   * 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
+        });
+        this.type = 'plugin';
+    }
+}
+const isPlugin = (cwd)=>{
+    const packageJSONPath = path$1.join(cwd, PROJECT_PACKAGE_JSON);
+    try {
+        fse.accessSync(packageJSONPath);
+    } catch  {
+        throw new Error(`Could not find a ${PROJECT_PACKAGE_JSON} file in ${cwd}`);
+    }
+    const packageJSONBuffer = fse.readFileSync(packageJSONPath);
+    const packageJSON = JSON.parse(packageJSONBuffer.toString());
+    return packageJSON?.strapi?.kind === 'plugin';
+};
+// TODO: make this async so we can use async file methods
+const projectFactory = (cwd)=>{
+    fse.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');
+    }
+}
+
+class UnexpectedError extends Error {
+    constructor(){
+        super('Unexpected Error');
+    }
+}
+class NPMCandidateNotFoundError extends Error {
+    constructor(target, message = `Couldn't find a valid NPM candidate for "${target}"`){
+        super(message);
+        this.target = target;
+    }
+}
+class AbortedError extends Error {
+    constructor(message = 'Upgrade aborted'){
+        super(message);
+    }
+}
+const unknownToError = (e)=>{
+    if (e instanceof Error) {
+        return e;
+    }
+    if (typeof e === 'string') {
+        return new Error(e);
+    }
+    return new UnexpectedError();
+};
+
+const CODEMOD_CODE_SUFFIX = 'code';
+const CODEMOD_JSON_SUFFIX = 'json';
+const CODEMOD_ALLOWED_SUFFIXES = [
+    CODEMOD_CODE_SUFFIX,
+    CODEMOD_JSON_SUFFIX
+];
+const CODEMOD_EXTENSION = 'ts';
+const CODEMOD_FILE_REGEXP = new RegExp(`^.+[.](${CODEMOD_ALLOWED_SUFFIXES.join('|')})[.]${CODEMOD_EXTENSION}$`);
+
+var constants$2 = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  CODEMOD_ALLOWED_SUFFIXES: CODEMOD_ALLOWED_SUFFIXES,
+  CODEMOD_CODE_SUFFIX: CODEMOD_CODE_SUFFIX,
+  CODEMOD_EXTENSION: CODEMOD_EXTENSION,
+  CODEMOD_FILE_REGEXP: CODEMOD_FILE_REGEXP,
+  CODEMOD_JSON_SUFFIX: CODEMOD_JSON_SUFFIX
+});
+
+class Codemod {
+    createUID() {
+        const name = this.format({
+            stripExtension: true,
+            stripKind: true,
+            stripHyphens: false
+        });
+        const kind = this.kind;
+        const version = this.version.raw;
+        return `${version}-${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;
+    }
+    constructor(options){
+        this.kind = options.kind;
+        this.version = options.version;
+        this.baseDirectory = options.baseDirectory;
+        this.filename = options.filename;
+        this.path = path$1.join(this.baseDirectory, this.version.raw, this.filename);
+        this.uid = this.createUID();
+    }
+}
+const codemodFactory = (options)=>new Codemod(options);
+
+const INTERNAL_CODEMODS_DIRECTORY = path$1.join(__dirname, '..', '..', 'resources', 'codemods' // upgrade/resources/codemods
+);
+
+var constants$1 = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  INTERNAL_CODEMODS_DIRECTORY: INTERNAL_CODEMODS_DIRECTORY
+});
+
+class CodemodRepository {
+    refresh() {
+        this.refreshAvailableVersions();
+        this.refreshAvailableFiles();
+        return this;
+    }
+    count(version) {
+        return this.findByVersion(version).length;
+    }
+    versionExists(version) {
+        return version.raw in this.groups;
+    }
+    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 by range if provided in the query
+        .filter(maybeFilterByRange)// Transform version/codemods tuples into regular objects
+        .map(([version, codemods])=>({
+                version: semVerFactory(version),
+                // Filter by UID if provided in the query
+                codemods: codemods.filter(maybeFilterByUIDs)
+            }))// Only return groups with at least 1 codemod
+        .filter(({ codemods })=>codemods.length > 0);
+        function maybeFilterByRange([version]) {
+            if (!isRangeInstance(q.range)) {
+                return true;
+            }
+            return q.range.test(version);
+        }
+        function maybeFilterByUIDs(codemod) {
+            if (q.uids === undefined) {
+                return true;
+            }
+            return q.uids.includes(codemod.uid);
+        }
+    }
+    findByVersion(version) {
+        const literalVersion = version.raw;
+        const codemods = this.groups[literalVersion];
+        return codemods ?? [];
+    }
+    findAll() {
+        const entries = Object.entries(this.groups);
+        return entries.map(([version, codemods])=>({
+                version: semVerFactory(version),
+                codemods
+            }));
+    }
+    refreshAvailableVersions() {
+        this.versions = fse.readdirSync(this.cwd) // Only keep root directories
+        .filter((filename)=>fse.statSync(path$1.join(this.cwd, filename)).isDirectory())// Paths should be valid semver
+        .filter((filename)=>semver.valid(filename) !== null)// Transform files names to SemVer instances
+        .map((version)=>semVerFactory(version))// Sort versions in ascending order
+        .sort(semver.compare);
+        return this;
+    }
+    refreshAvailableFiles() {
+        this.groups = {};
+        for (const version of this.versions){
+            this.refreshAvailableFilesForVersion(version);
+        }
+    }
+    refreshAvailableFilesForVersion(version) {
+        const literalVersion = version.raw;
+        const versionDirectory = path$1.join(this.cwd, literalVersion);
+        // Ignore obsolete versions
+        if (!fse.existsSync(versionDirectory)) {
+            return;
+        }
+        this.groups[literalVersion] = fse.readdirSync(versionDirectory)// Make sure the filenames are valid codemod files
+        .filter((filename)=>fse.statSync(path$1.join(versionDirectory, filename)).isFile()).filter((filename)=>CODEMOD_FILE_REGEXP.test(filename))// Transform the filenames into Codemod instances
+        .map((filename)=>{
+            const kind = parseCodemodKindFromFilename(filename);
+            const baseDirectory = this.cwd;
+            return codemodFactory({
+                kind,
+                baseDirectory,
+                version,
+                filename
+            });
+        });
+    }
+    constructor(cwd){
+        assert(fse.existsSync(cwd), `Invalid codemods directory provided "${cwd}"`);
+        this.cwd = cwd;
+        this.groups = {};
+        this.versions = [];
+    }
+}
+const parseCodemodKindFromFilename = (filename)=>{
+    const kind = filename.split('.').at(-2);
+    assert(kind !== undefined);
+    assert(CODEMOD_ALLOWED_SUFFIXES.includes(kind));
+    return kind;
+};
+const codemodRepositoryFactory = (cwd = INTERNAL_CODEMODS_DIRECTORY)=>{
+    return new CodemodRepository(cwd);
+};
+
+class CodemodRunner {
+    setRange(range) {
+        this.range = range;
+        return this;
+    }
+    setLogger(logger) {
+        this.logger = logger;
+        return this;
+    }
+    onSelectCodemods(callback) {
+        this.selectCodemodsCallback = callback;
+        return this;
+    }
+    dry(enabled = true) {
+        this.isDry = enabled;
+        return this;
+    }
+    createRepository(codemodsDirectory) {
+        const repository = codemodRepositoryFactory(codemodsDirectory ?? INTERNAL_CODEMODS_DIRECTORY);
+        // Make sure we have access to the latest snapshots of codemods on the system
+        repository.refresh();
+        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.');
+        }
+        try {
+            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));
+        }
+    }
+    async runByUID(uid, codemodsDirectory) {
+        const repository = this.createRepository(codemodsDirectory);
+        if (!repository.has(uid)) {
+            throw new Error(`Unknown codemod UID provided: ${uid}`);
+        }
+        // Note: Ignore the range when running with a UID
+        const codemods = repository.find({
+            uids: [
+                uid
+            ]
+        }).flatMap(({ codemods })=>codemods);
+        return this.safeRunAndReport(codemods);
+    }
+    async run(codemodsDirectory) {
+        const repository = this.createRepository(codemodsDirectory);
+        // Find codemods matching the given range
+        const codemodsInRange = repository.find({
+            range: this.range
+        });
+        // If a selection callback is set, use it, else keep every codemods found
+        const selectedCodemods = this.selectCodemodsCallback ? await this.selectCodemodsCallback(codemodsInRange) : codemodsInRange;
+        // If no codemods have been selected (either manually or automatically)
+        // Then ignore and return a successful report
+        if (selectedCodemods.length === 0) {
+            this.logger?.debug?.(`Found no codemods to run for ${versionRange(this.range)}`);
+            return successReport$1();
+        }
+        // Flatten the collection to a single list of codemods, the original list should already be sorted by version
+        const codemods = selectedCodemods.flatMap(({ codemods })=>codemods);
+        // Log (debug) the codemods by version
+        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, codemods] of Object.entries(codemodsByVersion)){
+            this.logger?.debug?.(`- ${version(semVerFactory(version$1))} (${codemods.length})`);
+        }
+        return this.safeRunAndReport(codemods);
+    }
+    constructor(project, range){
+        this.project = project;
+        this.range = range;
+        this.isDry = false;
+        this.logger = null;
+        this.selectCodemodsCallback = null;
+    }
+}
+const codemodRunnerFactory = (project, range)=>{
+    return new CodemodRunner(project, range);
+};
+const successReport$1 = ()=>({
+        success: true,
+        error: null
+    });
+const erroredReport$1 = (error)=>({
+        success: false,
+        error
+    });
+
+class Upgrader {
+    getNPMPackage() {
+        return this.npmPackage;
+    }
+    getProject() {
+        return this.project;
+    }
+    getTarget() {
+        return semVerFactory(this.target.raw);
+    }
+    setRequirements(requirements) {
+        this.requirements = requirements;
+        return this;
+    }
+    setTarget(target) {
+        this.target = target;
+        return this;
+    }
+    syncCodemodsTarget() {
+        // Extract the <major>.<minor>.<patch> version from the target and assign it to the codemods target
+        //
+        // This is useful when dealing with alphas, betas or release candidates:
+        // e.g. "5.0.0-beta.951" becomes "5.0.0"
+        //
+        // For experimental versions (e.g. "0.0.0-experimental.hex"), it is necessary to
+        // override the codemods target manually in order to run the appropriate ones.
+        this.codemodsTarget = semVerFactory(`${this.target.major}.${this.target.minor}.${this.target.patch}`);
+        this.logger?.debug?.(`The codemods target has been synced with the upgrade target. The codemod runner will now look for ${version(this.codemodsTarget)}`);
+        return this;
+    }
+    overrideCodemodsTarget(target) {
+        this.codemodsTarget = target;
+        this.logger?.debug?.(`Overriding the codemods target. The codemod runner will now look for ${version(target)}`);
+        return this;
+    }
+    setLogger(logger) {
+        this.logger = logger;
+        return this;
+    }
+    onConfirm(callback) {
+        this.confirmationCallback = callback;
+        return this;
+    }
+    dry(enabled = true) {
+        this.isDry = enabled;
+        return this;
+    }
+    addRequirement(requirement) {
+        this.requirements.push(requirement);
+        const fRequired = requirement.isRequired ? '(required)' : '(optional)';
+        this.logger?.debug?.(`Added a new requirement to the upgrade: ${highlight(requirement.name)} ${fRequired}`);
+        return this;
+    }
+    async upgrade() {
+        this.logger?.info?.(`Upgrading from ${version(this.project.strapiVersion)} to ${version(this.target)}`);
+        if (this.isDry) {
+            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?.(`Found ${highlight(npmVersionsMatches.length)} versions satisfying ${versionRange(range)}`);
+        try {
+            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
+            ]));
+            await this.runCodemods(codemodsRange);
+            // We need to refresh the project files to make sure we have
+            // the latest version of each file (including package.json) for the next steps
+            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
+            ]));
+            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);
+            if (pass) {
+                await this.onSuccessfulRequirement(requirement, context);
+            } else {
+                await this.onFailedRequirement(requirement, error);
+            }
+        }
+    }
+    async onSuccessfulRequirement(requirement, context) {
+        const hasChildren = requirement.children.length > 0;
+        if (hasChildren) {
+            await this.checkRequirements(requirement.children, context);
+        }
+    }
+    async onFailedRequirement(requirement, originalError) {
+        const errorMessage = `Requirement failed: ${originalError.message} (${highlight(requirement.name)})`;
+        const warningMessage = originalError.message;
+        const confirmationMessage = `Ignore optional requirement "${highlight(requirement.name)}" ?`;
+        const error = new Error(errorMessage);
+        if (requirement.isRequired) {
+            throw error;
+        }
+        this.logger?.warn?.(warningMessage);
+        const response = await this.confirmationCallback?.(confirmationMessage);
+        if (!response) {
+            throw error;
+        }
+    }
+    async updateDependencies() {
+        const { packageJSON, packageJSONPath } = this.project;
+        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`);
+        strapiDependencies.forEach((dependency)=>this.logger?.debug?.(`- ${dependency[0]} (${dependency[1]} -> ${this.target})`));
+        if (strapiDependencies.length === 0) {
+            return;
+        }
+        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')})`);
+            return;
+        }
+        await saveJSON(packageJSONPath, updatedPackageJSON);
+    }
+    getScopedStrapiDependencies(dependencies) {
+        const { strapiVersion } = this.project;
+        const strapiDependencies = [];
+        // Find all @strapi/* packages matching the current Strapi version
+        for (const [name, version] of Object.entries(dependencies)){
+            const isScopedStrapiPackage = name.startsWith(SCOPED_STRAPI_PACKAGE_PREFIX);
+            const isOnCurrentStrapiVersion = isValidSemVer(version) && version === strapiVersion.raw;
+            if (isScopedStrapiPackage && isOnCurrentStrapiVersion) {
+                strapiDependencies.push([
+                    name,
+                    semVerFactory(version)
+                ]);
+            }
+        }
+        return strapiDependencies;
+    }
+    async installDependencies() {
+        const projectPath = this.project.cwd;
+        const packageManagerName = await utils.packageManager.getPreferred(projectPath);
+        this.logger?.debug?.(`Using ${highlight(packageManagerName)} as package manager`);
+        if (this.isDry) {
+            this.logger?.debug?.(`Skipping dependencies installation (${chalk.italic('dry mode')})`);
+            return;
+        }
+        await utils.packageManager.installDependencies(projectPath, packageManagerName, {
+            stdout: this.logger?.stdout,
+            stderr: this.logger?.stderr
+        });
+    }
+    async runCodemods(range) {
+        const codemodRunner = codemodRunnerFactory(this.project, range);
+        codemodRunner.dry(this.isDry);
+        if (this.logger) {
+            codemodRunner.setLogger(this.logger);
+        }
+        await codemodRunner.run();
+    }
+    constructor(project, target, npmPackage){
+        this.project = project;
+        this.npmPackage = npmPackage;
+        this.target = target;
+        this.syncCodemodsTarget();
+        this.isDry = false;
+        this.requirements = [];
+        this.logger = null;
+        this.confirmationCallback = null;
+    }
+}
+/**
+ * Resolves the NPM target version based on the given project, target, and NPM package.
+ * If target is a SemVer, it directly finds it. If it's a release type (major, minor, patch),
+ * it calculates the range of versions for this release type and returns the latest version within this range.
+ */ const resolveNPMTarget = (project, target, npmPackage)=>{
+    // Semver
+    if (isSemverInstance(target)) {
+        const version = npmPackage.findVersion(target);
+        if (!version) {
+            throw new NPMCandidateNotFoundError(target);
+        }
+        return version;
+    }
+    // Release Types
+    if (isSemVerReleaseType(target)) {
+        const range = rangeFromVersions(project.strapiVersion, target);
+        const npmVersionsMatches = npmPackage.findVersionsInRange(range);
+        // The targeted version is the latest one that matches the given range
+        const version = npmVersionsMatches.at(-1);
+        if (!version) {
+            throw new NPMCandidateNotFoundError(range, `The project is already up-to-date (${target})`);
+        }
+        return version;
+    }
+    throw new NPMCandidateNotFoundError(target);
+};
+const upgraderFactory = (project, target, npmPackage)=>{
+    const npmTarget = resolveNPMTarget(project, target, npmPackage);
+    const semverTarget = semVerFactory(npmTarget.version);
+    if (semver.eq(semverTarget, project.strapiVersion)) {
+        throw new Error(`The project is already using v${semverTarget}`);
+    }
+    return new Upgrader(project, semverTarget, npmPackage);
+};
+const successReport = ()=>({
+        success: true,
+        error: null
+    });
+const erroredReport = (error)=>({
+        success: false,
+        error
+    });
+
+const STRAPI_PACKAGE_NAME = '@strapi/strapi';
+
+var constants = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  STRAPI_PACKAGE_NAME: STRAPI_PACKAGE_NAME
+});
+
+class Requirement {
+    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'));
+        }
+    }
+    constructor(name, testCallback, isRequired){
+        this.name = name;
+        this.testCallback = testCallback;
+        this.isRequired = isRequired ?? true;
+        this.children = [];
+    }
+}
+const ok = ()=>({
+        pass: true,
+        error: null
+    });
+const errored = (error)=>({
+        pass: false,
+        error
+    });
+const requirementFactory = (name, testCallback, isRequired)=>new Requirement(name, testCallback, isRequired);
+
+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;
+    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.`);
+    }
+});
+
+const REQUIRE_GIT_CLEAN_REPOSITORY = requirementFactory('REQUIRE_GIT_CLEAN_REPOSITORY', async (context)=>{
+    const git = simpleGit({
+        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({
+        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({
+        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());
+
+/**
+ * Handles the upgrade prompts when using the latest tag.
+ *
+ * - checks if an upgrade involves a major bump, warning and asking for user confirmation before proceeding
+ */ const latest = async (upgrader, options)=>{
+    // Exit if the upgrade target isn't the latest tag
+    if (options.target !== exports.ReleaseType.Latest) {
+        return;
+    }
+    // Retrieve utilities from the upgrader instance
+    const npmPackage = upgrader.getNPMPackage();
+    const target = upgrader.getTarget();
+    const project = upgrader.getProject();
+    const { strapiVersion: current } = project;
+    // Pre-formatted strings used in logs
+    const fTargetMajor = highlight(`v${target.major}`);
+    const fCurrentMajor = highlight(`v${current.major}`);
+    const fTarget = version(target);
+    const fCurrent = version(current);
+    // Flags
+    const isMajorUpgrade = target.major > current.major;
+    // Handle potential major upgrade, warns, and asks for confirmation to proceed
+    if (isMajorUpgrade) {
+        options.logger.warn(`Detected a major upgrade for the "${highlight(exports.ReleaseType.Latest)}" tag: ${fCurrent} > ${fTarget}`);
+        // Find the latest release in between the current one and the next major
+        const newerPackageRelease = npmPackage.findVersionsInRange(rangeFactory(`>${current.raw} <${target.major}`)).at(-1);
+        // If the project isn't on the latest version for the current major, emit a warning
+        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;
+    // Resolves the correct working directory based on the given input
+    const cwd = path$1.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);
+    // Load all available versions from the NPM registry
+    await npmPackage.refresh();
+    // Initialize the upgrade instance
+    // Throws during initialization if the provided target is incompatible with the current version
+    const upgrader = upgraderFactory(project, options.target, npmPackage).dry(options.dry ?? false).onConfirm(options.confirm ?? null).setLogger(logger);
+    // Manually override the target version for codemods if it's explicitly provided
+    if (codemodsTarget !== undefined) {
+        upgrader.overrideCodemodsTarget(codemodsTarget);
+    }
+    // Prompt user for confirmation details before upgrading
+    await runUpgradePrompts(upgrader, options);
+    // Add specific requirements before upgrading
+    addUpgradeRequirements(upgrader, options);
+    // Actually run the upgrade process once configured,
+    // The response contains information about the final status: success/error
+    const upgradeReport = await upgrader.upgrade();
+    if (!upgradeReport.success) {
+        throw upgradeReport.error;
+    }
+    timer.stop();
+    logger.info(`Completed in ${durationMs(timer.elapsedMs)}ms`);
+};
+const runUpgradePrompts = async (upgrader, options)=>{
+    if (options.target === exports.ReleaseType.Latest) {
+        await latest(upgrader, options);
+    }
+};
+const addUpgradeRequirements = (upgrader, options)=>{
+    // Don't add the same requirements when manually targeting a major upgrade
+    // using a semver as it's implied that the users know what they're doing
+    if (options.target === exports.ReleaseType.Major) {
+        upgrader.addRequirement(REQUIRE_AVAILABLE_NEXT_MAJOR).addRequirement(REQUIRE_LATEST_FOR_CURRENT_MAJOR);
+    }
+    // Make sure the git repository is in an optimal state before running the upgrade
+    // Mainly used to ease rollbacks in case the upgrade is corrupted
+    upgrader.addRequirement(REQUIRE_GIT.asOptional());
+};
+
+const resolvePath = (cwd)=>path$1.resolve(cwd ?? process.cwd());
+const getRangeFromTarget = (currentVersion, target)=>{
+    if (isSemverInstance(target)) {
+        return rangeFactory(target);
+    }
+    const { major, minor, patch } = currentVersion;
+    switch(target){
+        case exports.ReleaseType.Latest:
+            throw new Error("Can't use <latest> to create a codemods range: not implemented");
+        case exports.ReleaseType.Major:
+            return rangeFactory(`${major}`);
+        case exports.ReleaseType.Minor:
+            return rangeFactory(`${major}.${minor}`);
+        case exports.ReleaseType.Patch:
+            return rangeFactory(`${major}.${minor}.${patch}`);
+        default:
+            throw new Error(`Invalid target set: ${target}`);
+    }
+};
+const findRangeFromTarget = (project, target)=>{
+    // If a range is manually defined, use it
+    if (isRangeInstance(target)) {
+        return target;
+    }
+    // If the current project is a Strapi application
+    // Get the range from the given target
+    if (isApplicationProject(project)) {
+        return getRangeFromTarget(project.strapiVersion, target);
+    }
+    // Else, if the project is a Strapi plugin or anything else
+    // Set the range to match any version
+    return rangeFactory('*');
+};
+
+const runCodemods = async (options)=>{
+    const timer = timerFactory();
+    const { logger, uid } = options;
+    // Make sure we're resolving the correct working directory based on the given input
+    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 is defined, only run the selected codemod
+    if (uid !== undefined) {
+        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)}`);
+    // Create a codemod repository targeting the default location of the codemods
+    const repo = codemodRepositoryFactory();
+    // Make sure all the codemods are loaded
+    repo.refresh();
+    // Find groups of codemods matching the given range
+    const groups = repo.find({
+        range
+    });
+    // Flatten the groups into a simple codemod array
+    const codemods = groups.flatMap((collection)=>collection.codemods);
+    // Debug
+    logger.debug(`Found ${highlight(codemods.length)} codemods`);
+    // Don't log an empty table
+    if (codemods.length === 0) {
+        logger.info(`Found no codemods matching ${versionRange(range)}`);
+        return;
+    }
+    // Format the list to a pretty table
+    const fCodemods = codemodList(codemods);
+    logger.raw(fCodemods);
+};
+
+class Logger {
+    get isNotSilent() {
+        return !this.isSilent;
+    }
+    get errors() {
+        return this.nbErrorsCalls;
+    }
+    get warnings() {
+        return this.nbWarningsCalls;
+    }
+    get stdout() {
+        return this.isSilent ? undefined : process.stdout;
+    }
+    get stderr() {
+        return this.isSilent ? undefined : process.stderr;
+    }
+    setDebug(debug) {
+        this.isDebug = debug;
+        return this;
+    }
+    setSilent(silent) {
+        this.isSilent = silent;
+        return this;
+    }
+    debug(...args) {
+        const isDebugEnabled = this.isNotSilent && this.isDebug;
+        if (isDebugEnabled) {
+            console.log(chalk.cyan(`[DEBUG]\t[${nowAsISO()}]`), ...args);
+        }
+        return this;
+    }
+    error(...args) {
+        this.nbErrorsCalls += 1;
+        if (this.isNotSilent) {
+            console.error(chalk.red(`[ERROR]\t[${nowAsISO()}]`), ...args);
+        }
+        return this;
+    }
+    info(...args) {
+        if (this.isNotSilent) {
+            console.info(chalk.blue(`[INFO]\t[${new Date().toISOString()}]`), ...args);
+        }
+        return this;
+    }
+    raw(...args) {
+        if (this.isNotSilent) {
+            console.log(...args);
+        }
+        return this;
+    }
+    warn(...args) {
+        this.nbWarningsCalls += 1;
+        if (this.isNotSilent) {
+            console.warn(chalk.yellow(`[WARN]\t[${new Date().toISOString()}]`), ...args);
+        }
+        return this;
+    }
+    constructor(options = {}){
+        // Set verbosity options
+        this.isDebug = options.debug ?? false;
+        this.isSilent = options.silent ?? false;
+        // Initialize counters
+        this.nbErrorsCalls = 0;
+        this.nbWarningsCalls = 0;
+    }
+}
+const nowAsISO = ()=>new Date().toISOString();
+const loggerFactory = (options = {})=>new Logger(options);
+
+exports.AbortedError = AbortedError;
+exports.NPMCandidateNotFoundError = NPMCandidateNotFoundError;
+exports.UnexpectedError = UnexpectedError;
+exports.assertAppProject = assertAppProject;
+exports.assertPluginProject = assertPluginProject;
+exports.codeRunnerFactory = codeRunnerFactory;
+exports.codemodFactory = codemodFactory;
+exports.codemodList = codemodList;
+exports.codemodRepositoryFactory = codemodRepositoryFactory;
+exports.codemodUID = codemodUID;
+exports.constants = constants$4;
+exports.constants$1 = constants$3;
+exports.constants$2 = constants$2;
+exports.constants$3 = constants$1;
+exports.constants$4 = constants;
+exports.durationMs = durationMs;
+exports.fileScannerFactory = fileScannerFactory;
+exports.highlight = highlight;
+exports.isApplicationProject = isApplicationProject;
+exports.isLiteralSemVer = isLiteralSemVer;
+exports.isPluginProject = isPluginProject;
+exports.isRangeInstance = isRangeInstance;
+exports.isSemVerReleaseType = isSemVerReleaseType;
+exports.isSemverInstance = isSemverInstance;
+exports.isValidSemVer = isValidSemVer;
+exports.isValidStringifiedRange = isValidStringifiedRange;
+exports.jsonRunnerFactory = jsonRunnerFactory;
+exports.listCodemods = listCodemods;
+exports.loggerFactory = loggerFactory;
+exports.path = path;
+exports.projectDetails = projectDetails;
+exports.projectFactory = projectFactory;
+exports.projectType = projectType;
+exports.rangeFactory = rangeFactory;
+exports.rangeFromReleaseType = rangeFromReleaseType;
+exports.rangeFromVersions = rangeFromVersions;
+exports.reports = reports;
+exports.requirementFactory = requirementFactory;
+exports.runCodemods = runCodemods;
+exports.semVerFactory = semVerFactory;
+exports.timerFactory = timerFactory;
+exports.transform = transform;
+exports.types = types;
+exports.unknownToError = unknownToError;
+exports.upgrade = upgrade;
+exports.upgradeStep = upgradeStep;
+exports.upgraderFactory = upgraderFactory;
+exports.version = version;
+exports.versionRange = versionRange;
+//# sourceMappingURL=logger-DGi224NW.js.map