@fecommunity/reactpress 3.7.0 → 4.0.0-beta.0

package/lib/db-backup.js

@@ -1,67 +0,0 @@
-const fs = require('fs');
-const path = require('path');
-const { execSync } = require('child_process');
-const chalk = require('chalk');
-const { t } = require('./i18n');
-const { mysqldumpFromDbContainer } = require('./docker');
-
-function isLocalDbHost(host) {
-  const h = String(host || '').toLowerCase();
-  return h === '127.0.0.1' || h === 'localhost' || h === '::1' || h === '';
-}
-
-function isMysqldumpNotFoundError(err) {
-  const msg = `${err && err.message ? err.message : ''}\n${err && err.stderr ? err.stderr : ''}`;
-  if (err && err.status === 127) return true;
-  return /command not found|not recognized as an internal or external command/i.test(msg);
-}
-
-function parseEnv(projectRoot) {
-  const envPath = path.join(projectRoot, '.env');
-  const out = {};
-  try {
-    const content = fs.readFileSync(envPath, 'utf8');
-    for (const line of content.split('\n')) {
-      const m = line.match(/^([A-Z_]+)=(.*)$/);
-      if (m) out[m[1]] = m[2].trim().replace(/^['"]|['"]$/g, '');
-    }
-  } catch {
-    // ignore
-  }
-  return out;
-}
-
-async function runDbBackup(projectRoot, outputPath) {
-  const env = parseEnv(projectRoot);
-  const host = env.DB_HOST || '127.0.0.1';
-  const port = env.DB_PORT || '3306';
-  const user = env.DB_USER || 'root';
-  const password = env.DB_PASSWD || env.DB_PASSWORD || 'root';
-  const database = env.DB_DATABASE || 'reactpress';
-  const out =
-    outputPath ||
-    path.join(projectRoot, `reactpress-backup-${new Date().toISOString().replace(/[:.]/g, '-')}.sql`);
-
-  const cmd = `mysqldump -h ${host} -P ${port} -u ${user} -p${password} ${database}`;
-  console.log(chalk.cyan('[reactpress]'), t('db.backup.to', { path: out }));
-  try {
-    const dump = execSync(cmd, { encoding: 'utf8', maxBuffer: 50 * 1024 * 1024 });
-    fs.writeFileSync(out, dump, 'utf8');
-    console.log(chalk.green('[reactpress]'), t('db.backup.done'));
-    return out;
-  } catch (err) {
-    if (isMysqldumpNotFoundError(err) && isLocalDbHost(host)) {
-      const via = mysqldumpFromDbContainer(projectRoot, { user, password, database });
-      if (via.ok) {
-        console.log(chalk.cyan('[reactpress]'), t('db.backup.viaDocker'));
-        fs.writeFileSync(out, via.stdout, 'utf8');
-        console.log(chalk.green('[reactpress]'), t('db.backup.done'));
-        return out;
-      }
-    }
-    console.error(chalk.red('[reactpress]'), t('db.backup.fail'));
-    throw err;
-  }
-}
-
-module.exports = { runDbBackup };

package/lib/dev-banner.js

@@ -1,72 +0,0 @@
-const {
-  brand,
-  icon,
-  ok,
-  divider,
-  padRight,
-  terminalWidth,
-  gradientText,
-  palette,
-  pulseBar,
-  statusLights,
-} = require('../ui/theme');
-const {
-  loadClientSiteUrl,
-  loadServerSiteUrl,
-  getApiPrefix,
-  getHealthUrl,
-} = require('./http');
-const { t } = require('./i18n');
-
-function getDevUrls(projectRoot) {
-  const client = loadClientSiteUrl(projectRoot).replace(/\/$/, '');
-  const server = loadServerSiteUrl(projectRoot).replace(/\/$/, '');
-  const prefix = getApiPrefix(projectRoot).replace(/\/$/, '') || '/api';
-  return {
-    site: client,
-    admin: `${client}/admin`,
-    api: `${server}${prefix}`,
-    swagger: `${server}${prefix}`,
-    health: getHealthUrl(projectRoot),
-  };
-}
-
-function urlLine(key, url, { underline = true } = {}) {
-  const keyCol = brand.muted(padRight(key, 10));
-  const value = underline ? brand.accent.underline(url) : brand.dim(url);
-  return `  ${brand.accent('▸ ')}${keyCol}  ${value}`;
-}
-
-function printDevReadyBanner(projectRoot, { apiOnly = false } = {}) {
-  const urls = getDevUrls(projectRoot);
-  const w = Math.min(terminalWidth() - 4, 56);
-
-  console.log('');
-  console.log(
-    `  ${icon.ok}  ${gradientText(t('devBanner.ready'), [palette.green, palette.accent], { bold: true })}  ${statusLights('online')}`
-  );
-  console.log(`  ${brand.primary('╔' + '═'.repeat(w) + '╗')}`);
-
-  if (!apiOnly) {
-    console.log(urlLine(t('devBanner.site'), urls.site));
-    console.log(urlLine(t('devBanner.admin'), urls.admin));
-  }
-  console.log(urlLine(t('devBanner.api'), urls.api));
-  console.log(urlLine(t('devBanner.swagger'), urls.swagger));
-  console.log(urlLine(t('devBanner.health'), urls.health, { underline: false }));
-
-  const pulseWidth = Math.min(20, w - 4);
-  if (pulseWidth > 6) {
-    console.log(
-      `  ${brand.muted('  ')}${pulseBar(pulseWidth, pulseWidth)}  ${brand.success(t('devBanner.allSystemsGo'))}`
-    );
-  }
-
-  console.log(`  ${brand.primary('╚' + '═'.repeat(w) + '╝')}`);
-  console.log(
-    `  ${brand.dim(t('devBanner.hint'))}  ${brand.muted('·')}  ${brand.dim(t('devBanner.shortcuts'))}`
-  );
-  console.log('');
-}
-
-module.exports = { getDevUrls, printDevReadyBanner };

package/lib/dev.js

@@ -1,141 +0,0 @@
-const { spawn } = require('child_process');
-const path = require('path');
-const ora = require('ora');
-const { runBuild } = require('./build');
-const { ensureProjectEnvironment } = require('./bootstrap');
-const { loadServerSiteUrl, loadClientSiteUrl, waitForHttp } = require('./http');
-const { printDevReadyBanner } = require('./dev-banner');
-const { ensureOriginalCwd } = require('./root');
-const { detectProjectType, hasClient, hasToolkit } = require('./project-type');
-const { t } = require('./i18n');
-
-const CLIENT_READY_TIMEOUT_MS = 120_000;
-const API_READY_TIMEOUT_MS = 180_000;
-
-function formatDevFailureHint() {
-  return [
-    t('dev.nextSteps'),
-    t('dev.nextDoctor'),
-    t('dev.nextDocker'),
-    t('dev.nextEnv'),
-  ].join('\n');
-}
-
-let apiChild;
-let webChild;
-let shuttingDown = false;
-
-function shutdown(signal = 'SIGINT') {
-  if (shuttingDown) return;
-  shuttingDown = true;
-  if (webChild && !webChild.killed) webChild.kill(signal);
-  if (apiChild && !apiChild.killed) apiChild.kill(signal);
-}
-
-async function buildToolkit(projectRoot) {
-  if (!hasToolkit(projectRoot)) return;
-  await runBuild('toolkit', projectRoot);
-}
-
-function spawnApi(projectRoot) {
-  const apiDevRunner = path.join(__dirname, 'api-dev-runner.js');
-  console.log(t('dev.startingApi'));
-  apiChild = spawn(process.execPath, [apiDevRunner], {
-    stdio: 'inherit',
-    cwd: projectRoot,
-    env: {
-      ...process.env,
-      REACTPRESS_ORIGINAL_CWD: projectRoot,
-    },
-  });
-
-  apiChild.on('close', (code) => {
-    if (shuttingDown) {
-      process.exit(code ?? 0);
-      return;
-    }
-    if (webChild && !webChild.killed) webChild.kill('SIGINT');
-    process.exit(code ?? 1);
-  });
-}
-
-async function waitForApiReady(projectRoot) {
-  const serverUrl = loadServerSiteUrl(projectRoot);
-  const spinner = ora({
-    text: t('dev.waitingApi', { url: serverUrl }),
-    color: 'magenta',
-    spinner: 'dots',
-  }).start();
-  const ready = await waitForHttp(serverUrl, API_READY_TIMEOUT_MS);
-  if (!ready) {
-    spinner.fail(t('dev.apiTimeout', { seconds: API_READY_TIMEOUT_MS / 1000 }));
-    shutdown('SIGINT');
-    process.exit(1);
-  }
-  spinner.succeed(t('dev.apiReady'));
-}
-
-function spawnClient(projectRoot) {
-  webChild = spawn('pnpm', ['run', '--dir', './client', 'dev'], {
-    stdio: 'inherit',
-    shell: true,
-    cwd: projectRoot,
-  });
-
-  const clientUrl = loadClientSiteUrl(projectRoot);
-  waitForHttp(clientUrl, CLIENT_READY_TIMEOUT_MS).then((clientReady) => {
-    if (clientReady) {
-      printDevReadyBanner(projectRoot);
-    } else {
-      console.warn(
-        t('dev.clientSlow', {
-          seconds: CLIENT_READY_TIMEOUT_MS / 1000,
-          url: clientUrl,
-        })
-      );
-    }
-  });
-
-  webChild.on('close', (code) => {
-    if (!shuttingDown) shutdown('SIGINT');
-    process.exit(code ?? 0);
-  });
-}
-
-async function startDevStack(projectRoot) {
-  const includeClient = hasClient(projectRoot);
-
-  spawnApi(projectRoot);
-  await waitForApiReady(projectRoot);
-  printDevReadyBanner(projectRoot, { apiOnly: !includeClient });
-
-  if (!includeClient) {
-    console.log(t('dev.standaloneHint'));
-    return;
-  }
-  spawnClient(projectRoot);
-}
-
-async function runDev(projectRoot = ensureOriginalCwd()) {
-  process.on('SIGINT', () => shutdown('SIGINT'));
-  process.on('SIGTERM', () => shutdown('SIGTERM'));
-
-  try {
-    const result = await ensureProjectEnvironment(projectRoot);
-    if (result.message) console.log(`[reactpress] ${result.message}`);
-  } catch (err) {
-    console.error(t('dev.envFailed'), err.message || err);
-    console.error(formatDevFailureHint());
-    process.exit(1);
-  }
-
-  await buildToolkit(projectRoot);
-  await startDevStack(projectRoot);
-}
-
-module.exports = {
-  runDev,
-  buildToolkit,
-  startDevStack,
-  detectProjectType,
-};

package/lib/docker.js

@@ -1,275 +0,0 @@
-const fs = require('fs');
-const path = require('path');
-const { spawn, execSync, spawnSync } = require('child_process');
-const ora = require('ora');
-const { ensureOriginalCwd } = require('./root');
-const { detectProjectType, hasClient } = require('./project-type');
-const { t } = require('./i18n');
-
-function isDockerRunning() {
-  try {
-    execSync('docker info', { stdio: 'ignore' });
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-function pickDockerComposeCommand() {
-  const v2 = spawnSync('docker', ['compose', 'version'], { stdio: 'ignore' });
-  if (v2.status === 0) return { command: 'docker', baseArgs: ['compose'] };
-
-  const v1 = spawnSync('docker-compose', ['version'], { stdio: 'ignore' });
-  if (v1.status === 0) return { command: 'docker-compose', baseArgs: [] };
-
-  return { command: 'docker', baseArgs: ['compose'] };
-}
-
-/**
- * Resolve which docker-compose file to use for the current project.
- *
- * - Monorepo checkouts use `docker-compose.dev.yml` at the repo root.
- * - Standalone projects use `.reactpress/docker-compose.yml` (managed by init).
- *
- * @returns {{ composeFile: string, cwd: string, type: 'monorepo' | 'standalone' }}
- */
-function resolveComposeContext(projectRoot) {
-  const type = detectProjectType(projectRoot);
-  if (type === 'monorepo') {
-    const composeFile = path.join(projectRoot, 'docker-compose.dev.yml');
-    if (fs.existsSync(composeFile)) {
-      return { composeFile, cwd: projectRoot, type };
-    }
-  }
-  const standaloneCompose = path.join(projectRoot, '.reactpress', 'docker-compose.yml');
-  if (fs.existsSync(standaloneCompose)) {
-    return { composeFile: standaloneCompose, cwd: path.dirname(standaloneCompose), type: 'standalone' };
-  }
-  const fallback = path.join(projectRoot, 'docker-compose.dev.yml');
-  return { composeFile: fallback, cwd: projectRoot, type };
-}
-
-function runCompose(args, ctx, options = {}) {
-  const { command, baseArgs } = pickDockerComposeCommand();
-  return spawnSync(
-    command,
-    [...baseArgs, '-f', ctx.composeFile, ...args],
-    { stdio: options.stdio ?? 'inherit', cwd: ctx.cwd, ...options }
-  );
-}
-
-function stopDockerServices(projectRoot) {
-  console.log(t('docker.stopping'));
-  const ctx = resolveComposeContext(projectRoot);
-  const result = runCompose(['down'], ctx);
-  if (result.status !== 0) {
-    console.error(t('docker.stopFailed'));
-    throw new Error(t('docker.stopFailed'));
-  }
-  console.log(t('docker.stopped'));
-}
-
-function startDockerServices(projectRoot) {
-  console.log(t('docker.starting'));
-  if (!isDockerRunning()) {
-    throw new Error(t('docker.notRunning'));
-  }
-  try {
-    const { ensureNginxConfig } = require('./nginx');
-    const { configPath, created } = ensureNginxConfig(projectRoot, { mode: 'dev' });
-    if (created) {
-      console.log(t('nginx.configCreated', { path: configPath }));
-    }
-  } catch (err) {
-    console.warn(t('nginx.ensureWarn', { message: err.message || err }));
-  }
-  const ctx = resolveComposeContext(projectRoot);
-  const result = runCompose(['up', '-d'], ctx);
-  if (result.status !== 0) {
-    throw new Error(t('docker.notRunning'));
-  }
-  console.log(t('docker.started'));
-}
-
-function resolveDbContainerName(ctx, projectRoot) {
-  if (ctx.type === 'standalone') return 'reactpress_cli_db';
-  return 'reactpress_db';
-}
-
-function resolveDbCredentialsFromEnv(projectRoot) {
-  const envPath = path.join(projectRoot, '.env');
-  let user = 'reactpress';
-  let password = 'reactpress';
-  try {
-    const content = fs.readFileSync(envPath, 'utf8');
-    const u = content.match(/^DB_USER=(.+)$/m);
-    const p = content.match(/^(DB_PASSWD|DB_PASSWORD)=(.+)$/m);
-    if (u) user = u[1].trim().replace(/^['"]|['"]$/g, '');
-    if (p) password = p[2].trim().replace(/^['"]|['"]$/g, '');
-  } catch {
-    // ignore
-  }
-  return { user, password };
-}
-
-async function waitForMysql(projectRoot, maxAttempts = 30) {
-  const ctx = resolveComposeContext(projectRoot);
-  const container = resolveDbContainerName(ctx, projectRoot);
-  const { user, password } = resolveDbCredentialsFromEnv(projectRoot);
-
-  const spinner = ora({
-    text: t('docker.waitingMysql'),
-    color: 'magenta',
-    spinner: 'dots',
-  }).start();
-
-  let attempts = 0;
-  while (attempts < maxAttempts) {
-    const probe = spawnSync(
-      'docker',
-      ['exec', container, 'mysql', `-u${user}`, `-p${password}`, '-e', 'SELECT 1'],
-      { stdio: 'ignore' }
-    );
-    if (probe.status === 0) {
-      spinner.succeed(t('docker.mysqlReady'));
-      return true;
-    }
-    attempts += 1;
-    spinner.text = t('docker.waitingMysqlProgress', { attempts, max: maxAttempts });
-    await new Promise((r) => setTimeout(r, 1000));
-  }
-  spinner.fail(t('docker.mysqlTimeout'));
-  return false;
-}
-
-async function dockerStartWithDev(projectRoot) {
-  startDockerServices(projectRoot);
-  const ready = await waitForMysql(projectRoot);
-  if (!ready) {
-    throw new Error(t('docker.mysqlNotReady'));
-  }
-
-  if (!hasClient(projectRoot)) {
-    console.log(t('dev.standaloneHint'));
-    return;
-  }
-
-  const { buildToolkit } = require('./dev');
-  await buildToolkit(projectRoot);
-
-  const apiRunner = path.join(__dirname, 'api-dev-runner.js');
-  console.log(t('docker.startDevStack'));
-  console.log(t('docker.visitUrls'));
-
-  return new Promise((resolve, reject) => {
-    const child = spawn(
-      'npx',
-      [
-        'concurrently',
-        '-n',
-        'api,web',
-        '-c',
-        'blue,green',
-        `node "${apiRunner}"`,
-        'pnpm run --dir ./client dev',
-      ],
-      {
-        stdio: 'inherit',
-        shell: true,
-        cwd: projectRoot,
-        env: {
-          ...process.env,
-          REACTPRESS_ORIGINAL_CWD: projectRoot,
-        },
-      }
-    );
-
-    child.on('error', reject);
-    child.on('close', (code) => {
-      if (code !== 0) {
-        reject(Object.assign(new Error(t('docker.devProcessExit', { code })), { exitCode: code }));
-        return;
-      }
-      resolve();
-    });
-  });
-}
-
-/**
- * Run mysqldump inside the compose `db` container (MySQL image ships mysqldump).
- * Used when the host has no `mysqldump` binary but Docker DB is running.
- *
- * @returns {{ ok: true, stdout: string } | { ok: false, stderr: string }}
- */
-function mysqldumpFromDbContainer(projectRoot, { user, password, database }) {
-  const ctx = resolveComposeContext(projectRoot);
-  if (!fs.existsSync(ctx.composeFile)) {
-    return { ok: false, stderr: 'compose file missing' };
-  }
-  if (!isDockerRunning()) {
-    return { ok: false, stderr: 'docker not running' };
-  }
-  const container = resolveDbContainerName(ctx, projectRoot);
-  const res = spawnSync(
-    'docker',
-    ['exec', container, 'mysqldump', `-u${user}`, `-p${password}`, database],
-    { encoding: 'utf8', maxBuffer: 50 * 1024 * 1024 }
-  );
-  if (res.error) {
-    return { ok: false, stderr: res.error.message };
-  }
-  if (res.status !== 0) {
-    return { ok: false, stderr: res.stderr || res.stdout || `exit ${res.status}` };
-  }
-  return { ok: true, stdout: res.stdout };
-}
-
-async function runDockerCommand(command, projectRoot = ensureOriginalCwd(), extraArgs = []) {
-  const ctx = resolveComposeContext(projectRoot);
-  switch (command) {
-    case 'up':
-      startDockerServices(projectRoot);
-      await waitForMysql(projectRoot);
-      return;
-    case 'down':
-    case 'stop':
-      stopDockerServices(projectRoot);
-      return;
-    case 'start':
-      await dockerStartWithDev(projectRoot);
-      return;
-    case 'restart':
-      stopDockerServices(projectRoot);
-      await new Promise((r) => setTimeout(r, 2000));
-      startDockerServices(projectRoot);
-      await waitForMysql(projectRoot);
-      return;
-    case 'status': {
-      const res = runCompose(['ps'], ctx);
-      if (res.status !== 0) {
-        throw new Error(t('docker.unknownCommand', { command: 'ps' }));
-      }
-      return;
-    }
-    case 'logs': {
-      const service = extraArgs[0];
-      const args = ['logs', '-f'];
-      if (service) args.push(service);
-      runCompose(args, ctx);
-      return;
-    }
-    default:
-      throw new Error(t('docker.unknownCommand', { command }));
-  }
-}
-
-module.exports = {
-  runDockerCommand,
-  startDockerServices,
-  stopDockerServices,
-  waitForMysql,
-  isDockerRunning,
-  resolveComposeContext,
-  pickDockerComposeCommand,
-  mysqldumpFromDbContainer,
-};