create-strapi-app 5.12.1 → 5.12.3

package/dist/index.mjs

@@ -1,1296 +1,20 @@
-import path, { join as join$1, resolve, basename } from 'node:path';
-import os$1 from 'node:os';
+import { join, basename } from 'node:path';
+import os from 'node:os';
 import chalk from 'chalk';
 import commander from 'commander';
-import crypto, { randomUUID } from 'crypto';
+import crypto from 'crypto';
 import fse from 'fs-extra';
-import inquirer from 'inquirer';
-import { services, cli } from '@strapi/cloud-cli';
-import execa from 'execa';
-import url from 'node:url';
-import { Readable } from 'node:stream';
-import { pipeline } from 'node:stream/promises';
-import * as tar from 'tar';
-import retry from 'async-retry';
-import os from 'os';
-import _, { kebabCase, merge } from 'lodash';
-import { join } from 'path';
-import semver from 'semver';
-import { machineIdSync } from 'node-machine-id';
-
-async function directory() {
-    const { directory } = await inquirer.prompt([
-        {
-            type: 'input',
-            default: 'my-strapi-project',
-            name: 'directory',
-            message: 'What is the name of your project?'
-        }
-    ]);
-    return directory;
-}
-async function typescript() {
-    const { useTypescript } = await inquirer.prompt([
-        {
-            type: 'confirm',
-            name: 'useTypescript',
-            message: 'Start with Typescript?',
-            default: true
-        }
-    ]);
-    return useTypescript;
-}
-async function example() {
-    const { useExample } = await inquirer.prompt([
-        {
-            type: 'confirm',
-            name: 'useExample',
-            message: 'Start with an example structure & data?',
-            default: false
-        }
-    ]);
-    return useExample;
-}
-async function gitInit() {
-    const { gitInit } = await inquirer.prompt([
-        {
-            type: 'confirm',
-            name: 'gitInit',
-            message: 'Initialize a git repository?',
-            default: true
-        }
-    ]);
-    return gitInit;
-}
-async function installDependencies(packageManager) {
-    const { installDependencies } = await inquirer.prompt([
-        {
-            type: 'confirm',
-            name: 'installDependencies',
-            message: `Install dependencies with ${packageManager}?`,
-            default: true
-        }
-    ]);
-    return installDependencies;
-}
-
-// TODO: move styles to API
-const supportedStyles = {
-    magentaBright: chalk.magentaBright,
-    blueBright: chalk.blueBright,
-    yellowBright: chalk.yellowBright,
-    green: chalk.green,
-    red: chalk.red,
-    bold: chalk.bold,
-    italic: chalk.italic
-};
-function parseToChalk(template) {
-    let result = template;
-    for (const [color, chalkFunction] of Object.entries(supportedStyles)){
-        const regex = new RegExp(`{${color}}(.*?){/${color}}`, 'g');
-        result = result.replace(regex, (_, p1)=>chalkFunction(p1.trim()));
-    }
-    return result;
-}
-
-function assertCloudError(e) {
-    if (e.response === undefined) {
-        throw Error('Expected CloudError');
-    }
-}
-async function handleCloudLogin() {
-    const logger = services.createLogger({
-        silent: false,
-        debug: process.argv.includes('--debug'),
-        timestamp: false
-    });
-    const cloudApiService = await services.cloudApiFactory({
-        logger
-    });
-    const defaultErrorMessage = 'An error occurred while trying to interact with Strapi Cloud. Use strapi deploy command once the project is generated.';
-    try {
-        const { data: config } = await cloudApiService.config();
-        logger.log(parseToChalk(config.projectCreation.introText));
-    } catch (e) {
-        logger.debug(e);
-        logger.error(defaultErrorMessage);
-        return;
-    }
-    const { userChoice } = await inquirer.prompt([
-        {
-            type: 'list',
-            name: 'userChoice',
-            message: `Please log in or sign up.`,
-            choices: [
-                'Login/Sign up',
-                'Skip'
-            ]
-        }
-    ]);
-    if (userChoice !== 'Skip') {
-        const cliContext = {
-            logger,
-            cwd: process.cwd()
-        };
-        try {
-            await cli.login.action(cliContext);
-        } catch (e) {
-            logger.debug(e);
-            try {
-                assertCloudError(e);
-                if (e.response.status === 403) {
-                    const message = typeof e.response.data === 'string' ? e.response.data : 'We are sorry, but we are not able to log you into Strapi Cloud at the moment.';
-                    logger.warn(message);
-                    return;
-                }
-            } catch (e) {
-            /* empty */ }
-            logger.error(defaultErrorMessage);
-        }
-    }
-}
-
-const stripTrailingSlash = (str)=>{
-    return str.endsWith('/') ? str.slice(0, -1) : str;
-};
-// Merge template with new project being created
-async function copyTemplate(scope, rootPath) {
-    const { template } = scope;
-    if (!template) {
-        throw new Error('Missing template or example app option');
-    }
-    if (await isOfficialTemplate(template, scope.templateBranch)) {
-        await retry(()=>downloadGithubRepo(rootPath, {
-                owner: 'strapi',
-                repo: 'strapi',
-                branch: scope.templateBranch,
-                subPath: `templates/${template}`
-            }), {
-            retries: 3,
-            onRetry (err, attempt) {
-                console.log(`Retrying to download the template. Attempt ${attempt}. Error: ${err}`);
-            }
-        });
-        return;
-    }
-    if (isLocalTemplate(template)) {
-        const filePath = template.startsWith('file://') ? url.fileURLToPath(template) : template;
-        await fse.copy(filePath, rootPath);
-    }
-    if (isGithubShorthand(template)) {
-        const [owner, repo, ...pathSegments] = template.split('/');
-        const subPath = pathSegments.length ? pathSegments.join('/') : scope.templatePath;
-        await retry(()=>downloadGithubRepo(rootPath, {
-                owner,
-                repo,
-                branch: scope.templateBranch,
-                subPath
-            }), {
-            retries: 3,
-            onRetry (err, attempt) {
-                console.log(`Retrying to download the template. Attempt ${attempt}. Error: ${err}`);
-            }
-        });
-        return;
-    }
-    if (isGithubRepo(template)) {
-        const url = new URL(template);
-        const [owner, repo, t, branch, ...pathSegments] = stripTrailingSlash(url.pathname.slice(1)).split('/');
-        if (t !== undefined && t !== 'tree') {
-            throw new Error(`Invalid GitHub template URL: ${template}`);
-        }
-        if (scope.templateBranch) {
-            await retry(()=>downloadGithubRepo(rootPath, {
-                    owner,
-                    repo,
-                    branch: scope.templateBranch,
-                    subPath: scope.templatePath
-                }), {
-                retries: 3,
-                onRetry (err, attempt) {
-                    console.log(`Retrying to download the template. Attempt ${attempt}. Error: ${err}`);
-                }
-            });
-            return;
-        }
-        await retry(()=>downloadGithubRepo(rootPath, {
-                owner,
-                repo,
-                branch: decodeURIComponent(branch) ?? scope.templateBranch,
-                subPath: pathSegments.length ? decodeURIComponent(pathSegments.join('/')) : scope.templatePath
-            }), {
-            retries: 3,
-            onRetry (err, attempt) {
-                console.log(`Retrying to download the template. Attempt ${attempt}. Error: ${err}`);
-            }
-        });
-        throw new Error(`Invalid GitHub template URL: ${template}`);
-    }
-}
-async function downloadGithubRepo(rootPath, { owner, repo, branch, subPath }) {
-    const filePath = subPath ? subPath.split('/').join(path.posix.sep) : null;
-    let checkContentUrl = `https://api.github.com/repos/${owner}/${repo}/contents`;
-    if (filePath) {
-        checkContentUrl = `${checkContentUrl}/${filePath}`;
-    }
-    if (branch) {
-        checkContentUrl = `${checkContentUrl}?ref=${branch}`;
-    }
-    const checkRes = await fetch(checkContentUrl, {
-        method: 'HEAD'
-    });
-    if (checkRes.status !== 200) {
-        throw new Error(`Could not find a template at https://github.com/${owner}/${repo}${branch ? ` on branch ${branch}` : ''}${filePath ? ` at path ${filePath}` : ''}`);
-    }
-    let url = `https://api.github.com/repos/${owner}/${repo}/tarball`;
-    if (branch) {
-        url = `${url}/${branch}`;
-    }
-    const res = await fetch(url);
-    if (!res.body) {
-        throw new Error(`Failed to download ${url}`);
-    }
-    await pipeline(// @ts-expect-error - Readable is not a valid source
-    Readable.fromWeb(res.body), tar.x({
-        cwd: rootPath,
-        strip: filePath ? filePath.split('/').length + 1 : 1,
-        filter (path) {
-            if (filePath) {
-                return path.split('/').slice(1).join('/').startsWith(filePath);
-            }
-            return true;
-        }
-    }));
-}
-function isLocalTemplate(template) {
-    return template.startsWith('file://') || fse.existsSync(path.isAbsolute(template) ? template : path.resolve(process.cwd(), template));
-}
-function isGithubShorthand(value) {
-    if (isValidUrl(value)) {
-        return false;
-    }
-    return /^[\w-]+\/[\w-.]+(\/[\w-.]+)*$/.test(value);
-}
-function isGithubRepo(value) {
-    try {
-        const url = new URL(value);
-        return url.origin === 'https://github.com';
-    } catch  {
-        return false;
-    }
-}
-function isValidUrl(value) {
-    try {
-        // eslint-disable-next-line no-new
-        new URL(value);
-        return true;
-    } catch  {
-        return false;
-    }
-}
-const OFFICIAL_NAME_REGEX = /^[a-zA-Z]*$/;
-async function isOfficialTemplate(template, branch) {
-    if (isValidUrl(template) || !OFFICIAL_NAME_REGEX.test(template)) {
-        return false;
-    }
-    const res = await fetch(`https://api.github.com/repos/strapi/strapi/contents/templates/${template}?${branch ? `ref=${branch}` : ''}`, {
-        method: 'HEAD'
-    });
-    return res.status === 200;
-}
-
-async function isInGitRepository(rootDir) {
-    try {
-        await execa('git', [
-            'rev-parse',
-            '--is-inside-work-tree'
-        ], {
-            stdio: 'ignore',
-            cwd: rootDir
-        });
-        return true;
-    } catch (_) {
-        return false;
-    }
-}
-async function isInMercurialRepository(rootDir) {
-    try {
-        await execa('hg', [
-            '-cwd',
-            '.',
-            'root'
-        ], {
-            stdio: 'ignore',
-            cwd: rootDir
-        });
-        return true;
-    } catch (_) {
-        return false;
-    }
-}
-async function tryGitInit(rootDir) {
-    try {
-        await execa('git', [
-            '--version'
-        ], {
-            stdio: 'ignore'
-        });
-        if (await isInGitRepository(rootDir) || await isInMercurialRepository(rootDir)) {
-            return false;
-        }
-        await execa('git', [
-            'init'
-        ], {
-            stdio: 'ignore',
-            cwd: rootDir
-        });
-        await execa('git', [
-            'add',
-            '.'
-        ], {
-            stdio: 'ignore',
-            cwd: rootDir
-        });
-        await execa('git', [
-            'commit',
-            '-m',
-            'Initial commit from Strapi'
-        ], {
-            stdio: 'ignore',
-            cwd: rootDir
-        });
-        return true;
-    } catch (e) {
-        console.error('Error while trying to initialize git:', e);
-        return false;
-    }
-}
-
-// Add properties from the package.json strapi key in the metadata
-function addPackageJsonStrapiMetadata(metadata, scope) {
-    const { packageJsonStrapi = {} } = scope;
-    return _.defaults(metadata, packageJsonStrapi);
-}
-const boolToString = (value)=>(value === true).toString();
-const getProperties = (scope, error)=>{
-    const eventProperties = {
-        error: typeof error === 'string' ? error : error && error.message
-    };
-    const userProperties = {
-        os: os.type(),
-        osPlatform: os.platform(),
-        osArch: os.arch(),
-        osRelease: os.release(),
-        nodeVersion: process.versions.node
-    };
-    const groupProperties = {
-        version: scope.strapiVersion,
-        docker: scope.docker,
-        useYarn: scope.packageManager === 'yarn',
-        packageManager: scope.packageManager,
-        /** @deprecated */ useTypescriptOnServer: boolToString(scope.useTypescript),
-        /** @deprecated */ useTypescriptOnAdmin: boolToString(scope.useTypescript),
-        useTypescript: boolToString(scope.useTypescript),
-        isHostedOnStrapiCloud: process.env.STRAPI_HOSTING === 'strapi.cloud',
-        noRun: boolToString(scope.runApp),
-        projectId: scope.uuid,
-        useExample: boolToString(scope.useExample),
-        gitInit: boolToString(scope.gitInit),
-        installDependencies: boolToString(scope.installDependencies)
-    };
-    return {
-        eventProperties,
-        userProperties,
-        groupProperties: addPackageJsonStrapiMetadata(groupProperties, scope)
-    };
-};
-function trackEvent(event, payload) {
-    if (process.env.NODE_ENV === 'test') {
-        return;
-    }
-    try {
-        return fetch('https://analytics.strapi.io/api/v2/track', {
-            method: 'POST',
-            body: JSON.stringify({
-                event,
-                ...payload
-            }),
-            signal: AbortSignal.timeout(1000),
-            headers: {
-                'Content-Type': 'application/json',
-                'X-Strapi-Event': event
-            }
-        }).catch(()=>{});
-    } catch (err) {
-        /** ignore errors */ return Promise.resolve();
-    }
-}
-async function trackError({ scope, error }) {
-    const properties = getProperties(scope, error);
-    try {
-        return await trackEvent('didNotCreateProject', {
-            deviceId: scope.deviceId,
-            ...properties
-        });
-    } catch (err) {
-        /** ignore errors */ return Promise.resolve();
-    }
-}
-async function trackUsage({ event, scope, error }) {
-    const properties = getProperties(scope, error);
-    try {
-        return await trackEvent(event, {
-            deviceId: scope.deviceId,
-            ...properties
-        });
-    } catch (err) {
-        /** ignore errors */ return Promise.resolve();
-    }
-}
-
-const engines = {
-    node: '>=18.0.0 <=22.x.x',
-    npm: '>=6.0.0'
-};
-
-async function createPackageJSON(scope) {
-    const { sortPackageJson } = await import('sort-package-json');
-    const pkgJSONPath = join(scope.rootPath, 'package.json');
-    const existingPkg = await fse.readJSON(pkgJSONPath).catch(()=>({}));
-    const pkg = {
-        name: kebabCase(scope.name),
-        private: true,
-        version: '0.1.0',
-        description: 'A Strapi application',
-        devDependencies: scope.devDependencies ?? {},
-        dependencies: scope.dependencies ?? {},
-        strapi: {
-            ...scope.packageJsonStrapi ?? {},
-            uuid: scope.uuid
-        },
-        engines
-    };
-    // copy templates
-    await fse.writeJSON(pkgJSONPath, sortPackageJson(merge(existingPkg, pkg)), {
-        spaces: 2
-    });
-}
-
-const generateASecret = ()=>crypto.randomBytes(16).toString('base64');
-const envTmpl = `
-# Server
-HOST=0.0.0.0
-PORT=1337
-
-# Secrets
-APP_KEYS=<%= appKeys %>
-API_TOKEN_SALT=<%= apiTokenSalt %>
-ADMIN_JWT_SECRET=<%= adminJwtToken %>
-TRANSFER_TOKEN_SALT=<%= transferTokenSalt %>
-
-# Database
-DATABASE_CLIENT=<%= database.client %>
-DATABASE_HOST=<%= database.connection.host %>
-DATABASE_PORT=<%= database.connection.port %>
-DATABASE_NAME=<%= database.connection.database %>
-DATABASE_USERNAME=<%= database.connection.username %>
-DATABASE_PASSWORD=<%= database.connection.password %>
-DATABASE_SSL=<%= database.connection.ssl %>
-DATABASE_FILENAME=<%= database.connection.filename %>
-`;
-function generateDotEnv(scope) {
-    const compile = _.template(envTmpl);
-    return compile({
-        appKeys: new Array(4).fill(null).map(generateASecret).join(','),
-        apiTokenSalt: generateASecret(),
-        transferTokenSalt: generateASecret(),
-        adminJwtToken: generateASecret(),
-        database: {
-            client: scope.database.client,
-            connection: {
-                ...scope.database.connection,
-                ssl: scope.database.connection?.ssl || false
-            }
-        }
-    });
-}
-
-function isStderrError(error) {
-    return typeof error === 'object' && error !== null && 'stderr' in error && typeof error.stderr === 'string';
-}
-
-const MAX_PREFIX_LENGTH = 8;
-const badge = (text, bgColor, textColor = chalk.black)=>{
-    const wrappedText = ` ${text} `;
-    const repeat = Math.max(0, MAX_PREFIX_LENGTH - wrappedText.length);
-    return ' '.repeat(repeat) + bgColor(textColor(wrappedText));
-};
-const textIndent = (text, indentFirst = true, indent = MAX_PREFIX_LENGTH + 2)=>{
-    const parts = Array.isArray(text) ? text : [
-        text
-    ];
-    return parts.map((part, i)=>{
-        if (i === 0 && !indentFirst) {
-            return part;
-        }
-        return ' '.repeat(indent) + part;
-    }).join('\n');
-};
-const logger = {
-    log (message) {
-        console.log(textIndent(message));
-    },
-    title (title, message) {
-        const prefix = badge(title, chalk.bgBlueBright);
-        console.log(`\n${prefix}  ${message}`);
-    },
-    info (message) {
-        console.log(`${' '.repeat(7)}${chalk.cyan('●')}  ${message}`);
-    },
-    success (message) {
-        console.log(`\n${' '.repeat(7)}${chalk.green('✓')}  ${chalk.green(message)}`);
-    },
-    fatal (message) {
-        const prefix = badge('Error', chalk.bgRed);
-        if (message) {
-            console.error(`\n${prefix}  ${textIndent(message, false)}\n`);
-        }
-        process.exit(1);
-    },
-    error (message) {
-        const prefix = badge('Error', chalk.bgRed);
-        console.error(`\n${prefix}  ${textIndent(message, false)}\n`);
-    },
-    warn (message) {
-        const prefix = badge('Warn', chalk.bgYellow);
-        console.warn(`\n${prefix}  ${textIndent(message, false)}\n`);
-    }
-};
-
-const baseGitIgnore = `
-############################
-# OS X
-############################
-
-.DS_Store
-.AppleDouble
-.LSOverride
-Icon
-.Spotlight-V100
-.Trashes
-._*
-
-
-############################
-# Linux
-############################
-
-*~
-
-
-############################
-# Windows
-############################
-
-Thumbs.db
-ehthumbs.db
-Desktop.ini
-$RECYCLE.BIN/
-*.cab
-*.msi
-*.msm
-*.msp
-
-
-############################
-# Packages
-############################
-
-*.7z
-*.csv
-*.dat
-*.dmg
-*.gz
-*.iso
-*.jar
-*.rar
-*.tar
-*.zip
-*.com
-*.class
-*.dll
-*.exe
-*.o
-*.seed
-*.so
-*.swo
-*.swp
-*.swn
-*.swm
-*.out
-*.pid
-
-
-############################
-# Logs and databases
-############################
-
-.tmp
-*.log
-*.sql
-*.sqlite
-*.sqlite3
-
-
-############################
-# Misc.
-############################
-
-*#
-ssl
-.idea
-nbproject
-public/uploads/*
-!public/uploads/.gitkeep
-.tsbuildinfo
-.eslintcache
-
-############################
-# Node.js
-############################
-
-lib-cov
-lcov.info
-pids
-logs
-results
-node_modules
-.node_history
-
-############################
-# Package managers
-############################
-
-.yarn/*
-!.yarn/cache
-!.yarn/unplugged
-!.yarn/patches
-!.yarn/releases
-!.yarn/sdks
-!.yarn/versions
-.pnp.*
-yarn-error.log
-
-############################
-# Tests
-############################
-
-coverage
-
-############################
-# Strapi
-############################
-
-.env
-license.txt
-exports
-.strapi
-dist
-build
-.strapi-updater.json
-.strapi-cloud.json
-`;
-const gitIgnore = baseGitIgnore.trim();
-
-const installArguments = [
-    'install'
-];
-// Set command line options for specific package managers, with full semver ranges
-const installArgumentsMap = {
-    npm: {
-        '*': [
-            '--legacy-peer-deps'
-        ]
-    },
-    yarn: {
-        '<4': [
-            '--network-timeout',
-            '1000000'
-        ],
-        '*': []
-    },
-    pnpm: {
-        '*': []
-    }
-};
-// Set environment variables for specific package managers, with full semver ranges
-const installEnvMap = {
-    yarn: {
-        '>=4': {
-            YARN_HTTP_TIMEOUT: '1000000'
-        },
-        '*': {}
-    },
-    npm: {
-        '*': {}
-    },
-    pnpm: {
-        '*': {}
-    }
-};
-/**
- * Retrieves the version of the specified package manager.
- *
- * Executes the package manager's `--version` command to determine its version.
- *
- * @param packageManager - The name of the package manager (e.g., 'npm', 'yarn', 'pnpm').
- * @param options - Optional execution options to pass to `execa`.
- * @returns A promise that resolves to the trimmed version string of the package manager.
- *
- * @throws Will throw an error if the package manager's version cannot be determined.
- */ const getPackageManagerVersion = async (packageManager, options)=>{
-    try {
-        const { stdout } = await execa(packageManager, [
-            '--version'
-        ], options);
-        return stdout.trim();
-    } catch (err) {
-        throw new Error(`Error detecting ${packageManager} version: ${err}`);
-    }
-};
-/**
- * Merges all matching semver ranges using a custom merge function.
- *
- * Iterates over the `versionMap`, checking if the provided `version` satisfies each semver range.
- * If it does, the corresponding value is merged using the provided `mergeFn`.
- * The merging starts with the value associated with the wildcard '*' key.
- *
- * @param version - The package manager version to check against the ranges.
- * @param versionMap - A map of semver ranges to corresponding values (arguments or environment variables).
- * @param mergeFn - A function that defines how to merge two values (accumulated and current).
- * @returns The merged result of all matching ranges.
- */ function mergeMatchingVersionRanges(version, versionMap, mergeFn) {
-    return Object.keys(versionMap).reduce((acc, range)=>{
-        if (semver.satisfies(version, range) || range === '*') {
-            return mergeFn(acc, versionMap[range]);
-        }
-        return acc;
-    }, versionMap['*']); // Start with the wildcard entry
-}
-function mergeArguments(acc, curr) {
-    return [
-        ...acc,
-        ...curr
-    ];
-}
-function mergeEnvVars(acc, curr) {
-    return {
-        ...acc,
-        ...curr
-    };
-}
-/**
- * Retrieves the install arguments and environment variables for a given package manager.
- *
- * This function determines the correct command line arguments and environment variables
- * based on the package manager's version. It uses predefined semver ranges to match
- * the package manager's version and merges all applicable settings.
- *
- * The arguments and environment variables are sourced from:
- *  - `installArgumentsMap` for command line arguments.
- *  - `installEnvMap` for environment variables.
- *
- * The function ensures that all matching semver ranges are considered and merged appropriately.
- * It always includes the base `installArguments` (e.g., `['install']`) and applies any additional
- * arguments or environment variables as defined by the matched version ranges.
- *
- * @param packageManager - The name of the package manager (e.g., 'npm', 'yarn', 'pnpm').
- * @param options - Optional execution options to pass to `execa`.
- * @returns An object containing:
- *  - `cmdArgs`: The full array of install arguments for the given package manager and version.
- *  - `envArgs`: The merged environment variables applicable to the package manager and version.
- *
- * @throws Will throw an error if the package manager version cannot be determined.
- */ const getInstallArgs = async (packageManager, options)=>{
-    const packageManagerVersion = await getPackageManagerVersion(packageManager, options);
-    // Get environment variables
-    const envMap = installEnvMap[packageManager];
-    const envArgs = packageManagerVersion ? mergeMatchingVersionRanges(packageManagerVersion, envMap, mergeEnvVars) : envMap['*'];
-    // Get install arguments
-    const argsMap = installArgumentsMap[packageManager];
-    const cmdArgs = packageManagerVersion ? mergeMatchingVersionRanges(packageManagerVersion, argsMap, mergeArguments) : argsMap['*'];
-    return {
-        envArgs,
-        cmdArgs: [
-            ...installArguments,
-            ...cmdArgs
-        ],
-        version: packageManagerVersion
-    };
-};
-
-async function createStrapi(scope) {
-    const { rootPath } = scope;
-    try {
-        await fse.ensureDir(rootPath);
-        await createApp(scope);
-    } catch (error) {
-        await fse.remove(rootPath);
-        throw error;
-    }
-}
-async function createApp(scope) {
-    const { rootPath, useTypescript, useExample, installDependencies, isQuickstart, template, packageManager, gitInit, runApp } = scope;
-    const shouldRunSeed = useExample && installDependencies;
-    await trackUsage({
-        event: 'willCreateProject',
-        scope
-    });
-    logger.title('Strapi', `Creating a new application at ${chalk.green(rootPath)}`);
-    if (!isQuickstart) {
-        await trackUsage({
-            event: 'didChooseCustomDatabase',
-            scope
-        });
-    } else {
-        await trackUsage({
-            event: 'didChooseQuickstart',
-            scope
-        });
-    }
-    if (!template) {
-        let templateName = useExample ? 'example' : 'vanilla';
-        if (!useTypescript) {
-            templateName = `${templateName}-js`;
-        }
-        const internalTemplatePath = join$1(__dirname, '../templates', templateName);
-        if (await fse.exists(internalTemplatePath)) {
-            await fse.copy(internalTemplatePath, rootPath);
-        }
-    } else {
-        try {
-            logger.info(`${chalk.cyan('Installing template')} ${template}`);
-            await copyTemplate(scope, rootPath);
-            logger.success('Template copied successfully.');
-        } catch (error) {
-            if (error instanceof Error) {
-                logger.fatal(`Template installation failed: ${error.message}`);
-            }
-            throw error;
-        }
-        if (!fse.existsSync(join$1(rootPath, 'package.json'))) {
-            logger.fatal(`Missing ${chalk.bold('package.json')} in template`);
-        }
-    }
-    await trackUsage({
-        event: 'didCopyProjectFiles',
-        scope
-    });
-    try {
-        await createPackageJSON(scope);
-        await trackUsage({
-            event: 'didWritePackageJSON',
-            scope
-        });
-        // ensure node_modules is created
-        await fse.ensureDir(join$1(rootPath, 'node_modules'));
-        // create config/database
-        await fse.writeFile(join$1(rootPath, '.env'), generateDotEnv(scope));
-        await trackUsage({
-            event: 'didCopyConfigurationFiles',
-            scope
-        });
-    } catch (err) {
-        await fse.remove(rootPath);
-        throw err;
-    }
-    if (installDependencies) {
-        try {
-            logger.title('deps', `Installing dependencies with ${chalk.cyan(packageManager)}`);
-            await trackUsage({
-                event: 'willInstallProjectDependencies',
-                scope
-            });
-            await runInstall(scope);
-            await trackUsage({
-                event: 'didInstallProjectDependencies',
-                scope
-            });
-            logger.success(`Dependencies installed`);
-        } catch (error) {
-            const stderr = isStderrError(error) ? error.stderr : '';
-            await trackUsage({
-                event: 'didNotInstallProjectDependencies',
-                scope,
-                error: stderr.slice(-1024)
-            });
-            logger.fatal([
-                chalk.bold('Oh, it seems that you encountered an error while installing dependencies in your project'),
-                '',
-                `Don't give up, your project was created correctly`,
-                '',
-                `Fix the issues mentioned in the installation errors and try to run the following command:`,
-                '',
-                `cd ${chalk.green(rootPath)} && ${chalk.cyan(packageManager)} install`
-            ]);
-        }
-    }
-    await trackUsage({
-        event: 'didCreateProject',
-        scope
-    });
-    // make sure a gitignore file is created regardless of the user using git or not
-    if (!await fse.exists(join$1(rootPath, '.gitignore'))) {
-        await fse.writeFile(join$1(rootPath, '.gitignore'), gitIgnore);
-    }
-    // Init git
-    if (gitInit) {
-        logger.title('git', 'Initializing git repository.');
-        await tryGitInit(rootPath);
-        logger.success('Initialized a git repository.');
-    }
-    if (shouldRunSeed) {
-        if (await fse.exists(join$1(rootPath, 'scripts/seed.js'))) {
-            logger.title('Seed', 'Seeding your database with sample data');
-            try {
-                await execa(packageManager, [
-                    'run',
-                    'seed:example'
-                ], {
-                    stdio: 'inherit',
-                    cwd: rootPath
-                });
-                logger.success('Sample data added to your database');
-            } catch (error) {
-                logger.error('Failed to seed your database. Skipping');
-            }
-        }
-    }
-    const cmd = chalk.cyan(`${packageManager} run`);
-    logger.title('Strapi', `Your application was created!`);
-    logger.log([
-        'Available commands in your project:',
-        '',
-        'Start Strapi in watch mode. (Changes in Strapi project files will trigger a server restart)',
-        `${cmd} develop`,
-        '',
-        'Start Strapi without watch mode.',
-        `${cmd} start`,
-        '',
-        'Build Strapi admin panel.',
-        `${cmd} build`,
-        '',
-        'Deploy Strapi project.',
-        `${cmd} deploy`,
-        ''
-    ]);
-    if (useExample) {
-        logger.log([
-            'Seed your database with sample data.',
-            `${cmd} seed:example`,
-            ''
-        ]);
-    }
-    logger.log([
-        'Display all available commands.',
-        `${cmd} strapi\n`
-    ]);
-    if (installDependencies) {
-        logger.log([
-            'To get started run',
-            '',
-            `${chalk.cyan('cd')} ${rootPath}`,
-            !shouldRunSeed && useExample ? `${cmd} seed:example && ${cmd} develop` : `${cmd} develop`
-        ]);
-    } else {
-        logger.log([
-            'To get started run',
-            '',
-            `${chalk.cyan('cd')} ${rootPath}`,
-            `${chalk.cyan(packageManager)} install`,
-            !shouldRunSeed && useExample ? `${cmd} seed:example && ${cmd} develop` : `${cmd} develop`
-        ]);
-    }
-    if (runApp && installDependencies) {
-        logger.title('Run', 'Running your Strapi application');
-        try {
-            await trackUsage({
-                event: 'willStartServer',
-                scope
-            });
-            await execa(packageManager, [
-                'run',
-                'develop'
-            ], {
-                stdio: 'inherit',
-                cwd: rootPath,
-                env: {
-                    FORCE_COLOR: '1'
-                }
-            });
-        } catch (error) {
-            if (typeof error === 'string' || error instanceof Error) {
-                await trackUsage({
-                    event: 'didNotStartServer',
-                    scope,
-                    error
-                });
-            }
-            logger.fatal('Failed to start your Strapi application');
-        }
-    }
-}
-async function runInstall({ rootPath, packageManager }) {
-    // include same cwd and env to ensure version check returns same version we use below
-    const { envArgs, cmdArgs } = await getInstallArgs(packageManager, {
-        cwd: rootPath,
-        env: {
-            ...process.env,
-            NODE_ENV: 'development'
-        }
-    });
-    const options = {
-        cwd: rootPath,
-        stdio: 'inherit',
-        env: {
-            ...process.env,
-            ...envArgs,
-            NODE_ENV: 'development'
-        }
-    };
-    const proc = execa(packageManager, cmdArgs, options);
-    return proc;
-}
-
-function checkNodeRequirements() {
-    const currentNodeVersion = process.versions.node;
-    // error if the node version isn't supported
-    if (!semver.satisfies(currentNodeVersion, engines.node)) {
-        logger.fatal([
-            chalk.red(`You are running ${chalk.bold(`Node.js ${currentNodeVersion}`)}`),
-            `Strapi requires ${chalk.bold(chalk.green(`Node.js ${engines.node}`))}`,
-            'Please make sure to use the right version of Node.'
-        ]);
-    } else if (semver.major(currentNodeVersion) % 2 !== 0) {
-        logger.warn([
-            chalk.yellow(`You are running ${chalk.bold(`Node.js ${currentNodeVersion}`)}`),
-            `Strapi only supports ${chalk.bold(chalk.green('LTS versions of Node.js'))}, other versions may not be compatible.`
-        ]);
-    }
-}
-
-// Checks if the an empty directory exists at rootPath
-async function checkInstallPath(directory) {
-    const rootPath = resolve(directory);
-    if (await fse.pathExists(rootPath)) {
-        const stat = await fse.stat(rootPath);
-        if (!stat.isDirectory()) {
-            logger.fatal(`${chalk.green(rootPath)} is not a directory. Make sure to create a Strapi application in an empty directory.`);
-        }
-        const files = await fse.readdir(rootPath);
-        if (files.length > 1) {
-            logger.fatal([
-                'You can only create a Strapi app in an empty directory',
-                `Make sure ${chalk.green(rootPath)} is empty.`
-            ]);
-        }
-    }
-    return rootPath;
-}
-
-function machineID() {
-    try {
-        const deviceId = machineIdSync();
-        return deviceId;
-    } catch (error) {
-        const deviceId = randomUUID();
-        return deviceId;
-    }
-}
-
-const DBOptions = [
-    'dbclient',
-    'dbhost',
-    'dbport',
-    'dbname',
-    'dbusername',
-    'dbpassword'
-];
-const VALID_CLIENTS = [
-    'sqlite',
-    'mysql',
-    'postgres'
-];
-const DEFAULT_CONFIG = {
-    client: 'sqlite',
-    connection: {
-        filename: '.tmp/data.db'
-    }
-};
-async function dbPrompt() {
-    const { useDefault } = await inquirer.prompt([
-        {
-            type: 'confirm',
-            name: 'useDefault',
-            message: 'Do you want to use the default database (sqlite) ?',
-            default: true
-        }
-    ]);
-    if (useDefault) {
-        return DEFAULT_CONFIG;
-    }
-    const { client } = await inquirer.prompt([
-        {
-            type: 'list',
-            name: 'client',
-            message: 'Choose your default database client',
-            choices: [
-                'sqlite',
-                'postgres',
-                'mysql'
-            ],
-            default: 'sqlite'
-        }
-    ]);
-    const questions = dbQuestions[client].map((q)=>q({
-            client
-        }));
-    const responses = await inquirer.prompt(questions);
-    return {
-        client,
-        connection: responses
-    };
-}
-async function getDatabaseInfos(options) {
-    if (options.skipDb) {
-        return DEFAULT_CONFIG;
-    }
-    if (options.dbclient && !VALID_CLIENTS.includes(options.dbclient)) {
-        logger.fatal(`Invalid --dbclient: ${options.dbclient}, expected one of ${VALID_CLIENTS.join(', ')}`);
-    }
-    const matchingArgs = DBOptions.filter((key)=>key in options);
-    const missingArgs = DBOptions.filter((key)=>!(key in options));
-    if (matchingArgs.length > 0 && matchingArgs.length !== DBOptions.length && options.dbclient !== 'sqlite') {
-        logger.fatal(`Required database arguments are missing: ${missingArgs.join(', ')}.`);
-    }
-    const hasDBOptions = DBOptions.some((key)=>key in options);
-    if (!hasDBOptions) {
-        if (options.quickstart) {
-            return DEFAULT_CONFIG;
-        }
-        return dbPrompt();
-    }
-    if (!options.dbclient) {
-        return logger.fatal('Please specify the database client');
-    }
-    const database = {
-        client: options.dbclient,
-        connection: {
-            host: options.dbhost,
-            port: options.dbport,
-            database: options.dbname,
-            username: options.dbusername,
-            password: options.dbpassword,
-            filename: options.dbfile
-        }
-    };
-    if (options.dbssl !== undefined) {
-        database.connection.ssl = options.dbssl === 'true';
-    }
-    return database;
-}
-const sqlClientModule = {
-    mysql: {
-        mysql2: '3.9.8'
-    },
-    postgres: {
-        pg: '8.8.0'
-    },
-    sqlite: {
-        'better-sqlite3': '11.3.0'
-    }
-};
-function addDatabaseDependencies(scope) {
-    scope.dependencies = {
-        ...scope.dependencies,
-        ...sqlClientModule[scope.database.client]
-    };
-}
-const DEFAULT_PORTS = {
-    postgres: 5432,
-    mysql: 3306,
-    sqlite: undefined
-};
-const database = ()=>({
-        type: 'input',
-        name: 'database',
-        message: 'Database name:',
-        default: 'strapi',
-        validate (value) {
-            if (value.includes('.')) {
-                return `The database name can't contain a "."`;
-            }
-            return true;
-        }
-    });
-const host = ()=>({
-        type: 'input',
-        name: 'host',
-        message: 'Host:',
-        default: '127.0.0.1'
-    });
-const port = ({ client })=>({
-        type: 'input',
-        name: 'port',
-        message: 'Port:',
-        default: DEFAULT_PORTS[client]
-    });
-const username = ()=>({
-        type: 'input',
-        name: 'username',
-        message: 'Username:'
-    });
-const password = ()=>({
-        type: 'password',
-        name: 'password',
-        message: 'Password:',
-        mask: '*'
-    });
-const ssl = ()=>({
-        type: 'confirm',
-        name: 'ssl',
-        message: 'Enable SSL connection:',
-        default: false
-    });
-const filename = ()=>({
-        type: 'input',
-        name: 'filename',
-        message: 'Filename:',
-        default: '.tmp/data.db'
-    });
-const dbQuestions = {
-    sqlite: [
-        filename
-    ],
-    postgres: [
-        database,
-        host,
-        port,
-        username,
-        password,
-        ssl
-    ],
-    mysql: [
-        database,
-        host,
-        port,
-        username,
-        password,
-        ssl
-    ]
-};
-
-const { version } = fse.readJSONSync(join$1(__dirname, '..', 'package.json'));
+import { directory, example, typescript, installDependencies, gitInit } from './prompts.mjs';
+import { handleCloudLogin } from './cloud.mjs';
+import { createStrapi } from './create-strapi.mjs';
+import { checkNodeRequirements } from './utils/check-requirements.mjs';
+import { checkInstallPath } from './utils/check-install-path.mjs';
+import { machineID } from './utils/machine-id.mjs';
+import { trackError } from './utils/usage.mjs';
+import { getDatabaseInfos, addDatabaseDependencies } from './utils/database.mjs';
+import { logger } from './utils/logger.mjs';
+
+const { version } = fse.readJSONSync(join(__dirname, '..', 'package.json'));
 const command = new commander.Command('create-strapi-app').version(version).arguments('[directory]').usage('[directory] [options]').option('--quickstart', 'Quickstart app creation (deprecated)').option('--no-run', 'Do not start the application after it is created.')// setup options
 .option('--ts, --typescript', 'Initialize the project with TypeScript (default)').option('--js, --javascript', 'Initialize the project with Javascript')// Package manager options
 .option('--use-npm', 'Use npm as the project package manager').option('--use-yarn', 'Use yarn as the project package manager').option('--use-pnpm', 'Use pnpm as the project package manager')// dependencies options
@@ -1332,7 +56,7 @@ async function run(args) {
     if (!options.skipCloud) {
         await handleCloudLogin();
     }
-    const tmpPath = join$1(os$1.tmpdir(), `strapi${crypto.randomBytes(6).toString('hex')}`);
+    const tmpPath = join(os.tmpdir(), `strapi${crypto.randomBytes(6).toString('hex')}`);
     const scope = {
         rootPath,
         name: basename(rootPath),