@fecommunity/reactpress 2.0.0-beta.0 → 3.0.1

package/lib/api-dev.js

@@ -0,0 +1,85 @@
+const { spawn, spawnSync } = require('child_process');
+const path = require('path');
+const { ensureProjectEnvironment } = require('./bootstrap');
+const { isUsingMonorepoServer } = require('./paths');
+const { getMonorepoRoot } = require('./root');
+const { t } = require('./i18n');
+
+let apiChild;
+
+function stopApiDev(projectRoot) {
+  if (apiChild && !apiChild.killed) {
+    apiChild.kill('SIGTERM');
+  }
+  if (!isUsingMonorepoServer()) {
+    spawnSync('pnpm', ['exec', 'reactpress-cli', 'stop'], {
+      cwd: projectRoot,
+      stdio: 'inherit',
+    });
+  }
+}
+
+function startApiDev(projectRoot) {
+  if (isUsingMonorepoServer()) {
+    console.log(t('apiDev.modeServer'));
+    apiChild = spawn('pnpm', ['run', '--dir', './server', 'dev'], {
+      cwd: projectRoot,
+      stdio: 'inherit',
+      shell: true,
+      env: {
+        ...process.env,
+        REACTPRESS_ORIGINAL_CWD: projectRoot,
+      },
+    });
+  } else {
+    console.log(t('apiDev.modeCli'));
+    const start = spawnSync('pnpm', ['exec', 'reactpress-cli', 'start'], {
+      cwd: projectRoot,
+      stdio: 'inherit',
+    });
+    if (start.status !== 0) {
+      process.exit(start.status ?? 1);
+    }
+    console.log(t('apiDev.startedByCli'));
+    process.stdin.resume();
+    return;
+  }
+
+  if (apiChild) {
+    apiChild.on('close', (code) => {
+      process.exit(code ?? 0);
+    });
+    console.log(t('apiDev.ctrlCHint'));
+    console.log(t('apiDev.stopHint'));
+  }
+}
+
+async function runApiDev(projectRoot = process.env.REACTPRESS_ORIGINAL_CWD || getMonorepoRoot()) {
+  try {
+    await ensureProjectEnvironment(projectRoot);
+  } catch (err) {
+    console.error(t('dev.envFailed'), err.message || err);
+    process.exit(1);
+  }
+
+  process.on('SIGINT', () => {
+    stopApiDev(projectRoot);
+    process.exit(0);
+  });
+  process.on('SIGTERM', () => {
+    stopApiDev(projectRoot);
+    process.exit(0);
+  });
+
+  startApiDev(projectRoot);
+}
+
+function getApiDevScriptPath() {
+  return path.join(__dirname, 'api-dev-runner.js');
+}
+
+module.exports = {
+  runApiDev,
+  stopApiDev,
+  getApiDevScriptPath,
+};

package/lib/bootstrap.js

@@ -0,0 +1,114 @@
+const fs = require('fs');
+const path = require('path');
+const { pathToFileURL } = require('url');
+const { getMonorepoRoot, isMonorepoCheckout } = require('./root');
+const { getCliPackageRoot } = require('./paths');
+const { t } = require('./i18n');
+
+async function importCliModule(relativePath) {
+  const modulePath = path.join(getCliPackageRoot(), 'dist', relativePath);
+  return import(pathToFileURL(modulePath).href);
+}
+
+async function copyTemplateFile(src, dest) {
+  await fs.promises.mkdir(path.dirname(dest), { recursive: true });
+  await fs.promises.copyFile(src, dest);
+}
+
+async function initMonorepoProject(projectRoot, { force = false } = {}) {
+  const { getProjectPaths, getTemplatesDir } = await importCliModule('utils/paths.js');
+  const { saveConfig, syncEnvFromConfig } = await importCliModule('services/config.js');
+  const { ensureDatabase, ensureDatabaseHostPort } = await importCliModule('services/database.js');
+
+  const paths = getProjectPaths(projectRoot);
+  const templatesDir = getTemplatesDir();
+
+  if (fs.existsSync(paths.configPath) && !force) {
+    const config = await (await importCliModule('services/config.js')).loadConfig(projectRoot);
+    await ensureDatabaseHostPort(projectRoot, undefined, config);
+    const dbResult = await ensureDatabase(projectRoot, config);
+    if (!dbResult.ok) {
+      return { ok: false, projectRoot, message: dbResult.message };
+    }
+    return { ok: true, projectRoot, message: t('bootstrap.configReady') };
+  }
+
+  await fs.promises.mkdir(paths.reactpressDir, { recursive: true });
+  await copyTemplateFile(
+    path.join(templatesDir, 'docker-compose.yml'),
+    paths.dockerComposePath
+  );
+
+  const config = JSON.parse(
+    await fs.promises.readFile(path.join(templatesDir, 'config.default.json'), 'utf8')
+  );
+  await saveConfig(projectRoot, config);
+  await syncEnvFromConfig(projectRoot, config);
+
+  if (!fs.existsSync(paths.envPath) || force) {
+    await copyTemplateFile(path.join(templatesDir, 'env.default'), paths.envPath);
+    await syncEnvFromConfig(projectRoot, config);
+  }
+
+  await ensureDatabaseHostPort(projectRoot, undefined, config);
+  const dbResult = await ensureDatabase(projectRoot, config);
+
+  if (!dbResult.ok) {
+    return {
+      ok: true,
+      projectRoot,
+      message: t('bootstrap.projectDbPending', { message: dbResult.message }),
+    };
+  }
+
+  return {
+    ok: true,
+    projectRoot,
+    message: t('bootstrap.ready'),
+  };
+}
+
+async function ensureProjectEnvironment(projectRoot = getMonorepoRoot()) {
+  const root = path.resolve(projectRoot);
+  const { setProjectCwd } = await importCliModule('utils/cli-context.js');
+  setProjectCwd(root);
+
+  const { isReactPressProject, loadConfig } = await importCliModule('services/config.js');
+  const { ensureDatabase, ensureDatabaseHostPort } = await importCliModule('services/database.js');
+
+  if (!(await isReactPressProject(root))) {
+    if (isMonorepoCheckout(root)) {
+      const result = await initMonorepoProject(root);
+      if (!result.ok) {
+        throw new Error(result.message || t('bootstrap.initFailed'));
+      }
+      return result;
+    }
+
+    const { initProject } = await importCliModule('services/init.js');
+    const result = await initProject({ directory: root, force: false });
+    if (!result.ok) {
+      throw new Error(result.message || t('bootstrap.cliInitFailed'));
+    }
+    return result;
+  }
+
+  const config = await loadConfig(root);
+  await ensureDatabaseHostPort(root, undefined, config);
+  const dbResult = await ensureDatabase(root, config);
+  if (!dbResult.ok) {
+    throw new Error(
+      t('bootstrap.dbNotReady', {
+        message: dbResult.message || t('bootstrap.dbPendingShort'),
+      })
+    );
+  }
+
+  return { ok: true, projectRoot: root, message: t('bootstrap.dbReady') };
+}
+
+module.exports = {
+  ensureProjectEnvironment,
+  initMonorepoProject,
+  isMonorepoCheckout,
+};

package/lib/build.js

@@ -0,0 +1,75 @@
+const chalk = require('chalk');
+const { runSync } = require('./spawn');
+const { ensureOriginalCwd } = require('./root');
+const { t } = require('./i18n');
+
+const FORBIDDEN_SCRIPTS = new Set(['build']);
+
+/** @type {Record<string, { script: string, labelKey: string }[]>} */
+const BUILD_STEPS = {
+  toolkit: [{ script: 'build:toolkit', labelKey: 'build.label.toolkit' }],
+  server: [{ script: 'build:server', labelKey: 'build.label.server' }],
+  client: [{ script: 'build:client', labelKey: 'build.label.client' }],
+  docs: [{ script: 'build:docs', labelKey: 'build.label.docs' }],
+  all: [
+    { script: 'build:toolkit', labelKey: 'build.label.toolkit' },
+    { script: 'build:server', labelKey: 'build.label.server' },
+    { script: 'build:client', labelKey: 'build.label.client' },
+  ],
+};
+
+const TARGETS = Object.keys(BUILD_STEPS);
+
+const buildChildEnv = { REACTPRESS_BUILD_ACTIVE: '1' };
+
+async function runBuild(target = 'all', projectRoot = ensureOriginalCwd()) {
+  if (process.env.REACTPRESS_BUILD_ACTIVE === '1') {
+    throw new Error(t('build.recursive'));
+  }
+
+  const steps = BUILD_STEPS[target];
+  if (!steps) {
+    throw new Error(
+      t('build.unknownTarget', {
+        target,
+        available: TARGETS.join(', '),
+      })
+    );
+  }
+
+  const total = steps.length;
+  const buildStarted = Date.now();
+
+  if (total > 1) {
+    console.log(t('build.plan', { total }));
+  }
+
+  for (let i = 0; i < steps.length; i++) {
+    const { script, labelKey } = steps[i];
+    if (FORBIDDEN_SCRIPTS.has(script)) {
+      throw new Error(t('build.forbiddenScript', { script }));
+    }
+
+    const current = i + 1;
+    const label = t(labelKey);
+    const stepStarted = Date.now();
+
+    console.log(t('build.step', { current, total, label }));
+    try {
+      runSync('pnpm', ['run', script], { cwd: projectRoot, env: buildChildEnv });
+    } catch (err) {
+      console.error(chalk.red(t('build.stepFailed', { current, total, label })));
+      throw err;
+    }
+
+    const seconds = ((Date.now() - stepStarted) / 1000).toFixed(1);
+    console.log(chalk.green(t('build.stepDone', { current, total, label, seconds })));
+  }
+
+  if (total > 1) {
+    const totalSeconds = ((Date.now() - buildStarted) / 1000).toFixed(1);
+    console.log(chalk.green(t('build.done', { seconds: totalSeconds })));
+  }
+}
+
+module.exports = { runBuild, TARGETS, BUILD_STEPS };

package/lib/db-backup.js

@@ -0,0 +1,46 @@
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+const chalk = require('chalk');
+const { t } = require('./i18n');
+
+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) {
+    console.error(chalk.red('[reactpress]'), t('db.backup.fail'));
+    throw err;
+  }
+}
+
+module.exports = { runDbBackup };

package/lib/dev-banner.js

@@ -0,0 +1,40 @@
+const chalk = require('chalk');
+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 printDevReadyBanner(projectRoot, { apiOnly = false } = {}) {
+  const urls = getDevUrls(projectRoot);
+  console.log('');
+  console.log(chalk.bold.green(t('devBanner.ready')));
+  console.log(chalk.gray('  ─────────────────────────────────────────'));
+  if (!apiOnly) {
+    console.log(`  ${chalk.cyan(t('devBanner.site'))}     ${chalk.underline(urls.site)}`);
+    console.log(`  ${chalk.cyan(t('devBanner.admin'))}   ${chalk.underline(urls.admin)}`);
+  }
+  console.log(`  ${chalk.cyan('API')}      ${chalk.underline(urls.api)}`);
+  console.log(`  ${chalk.cyan('Swagger')}  ${chalk.underline(urls.swagger)}`);
+  console.log(`  ${chalk.cyan(t('devBanner.health'))} ${urls.health}`);
+  console.log(chalk.gray('  ─────────────────────────────────────────'));
+  console.log(chalk.gray(t('devBanner.hint')));
+  console.log('');
+}
+
+module.exports = { getDevUrls, printDevReadyBanner };

package/lib/dev.js

@@ -0,0 +1,122 @@
+const { spawn } = require('child_process');
+const path = require('path');
+const { runBuild } = require('./build');
+const { ensureProjectEnvironment } = require('./bootstrap');
+const { loadServerSiteUrl, loadClientSiteUrl, waitForHttp } = require('./http');
+const { printDevReadyBanner } = require('./dev-banner');
+const { ensureOriginalCwd } = require('./root');
+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) {
+  await runBuild('toolkit', projectRoot);
+}
+
+async function startDevStack(projectRoot) {
+  const serverUrl = loadServerSiteUrl(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);
+  });
+
+  console.log(t('dev.waitingApi', { url: serverUrl }));
+  const ready = await waitForHttp(serverUrl, API_READY_TIMEOUT_MS);
+  if (!ready) {
+    console.error(
+      t('dev.apiTimeout', { seconds: API_READY_TIMEOUT_MS / 1000 }),
+    );
+    shutdown('SIGINT');
+    process.exit(1);
+  }
+
+  printDevReadyBanner(projectRoot, { apiOnly: true });
+
+  console.log(t('dev.apiReady'));
+  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 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 };

package/lib/docker.js

@@ -0,0 +1,157 @@
+const { spawn, execSync } = require('child_process');
+const path = require('path');
+const { ensureOriginalCwd } = require('./root');
+const { t } = require('./i18n');
+
+function isDockerRunning() {
+  try {
+    execSync('docker info', { stdio: 'ignore' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function stopDockerServices(projectRoot) {
+  console.log(t('docker.stopping'));
+  try {
+    execSync('docker-compose -f docker-compose.dev.yml down', {
+      stdio: 'inherit',
+      cwd: projectRoot,
+    });
+    console.log(t('docker.stopped'));
+  } catch (error) {
+    console.error(t('docker.stopFailed'), error.message);
+    throw error;
+  }
+}
+
+function startDockerServices(projectRoot) {
+  console.log(t('docker.starting'));
+  if (!isDockerRunning()) {
+    throw new Error(t('docker.notRunning'));
+  }
+  execSync('docker-compose -f docker-compose.dev.yml up -d', {
+    stdio: 'inherit',
+    cwd: projectRoot,
+  });
+  console.log(t('docker.started'));
+}
+
+async function waitForMysql(maxAttempts = 30) {
+  console.log(t('docker.waitingMysql'));
+  let attempts = 0;
+  while (attempts < maxAttempts) {
+    try {
+      execSync('docker exec reactpress_db mysql -u reactpress -preactpress -e "SELECT 1"', {
+        stdio: 'ignore',
+      });
+      console.log(t('docker.mysqlReady'));
+      return true;
+    } catch {
+      attempts += 1;
+      if (attempts % 5 === 0) {
+        console.log(t('docker.waitingMysqlProgress', { attempts, max: maxAttempts }));
+      }
+      await new Promise((r) => setTimeout(r, 1000));
+    }
+  }
+  console.error(t('docker.mysqlTimeout'));
+  return false;
+}
+
+async function dockerStartWithDev(projectRoot) {
+  startDockerServices(projectRoot);
+  const ready = await waitForMysql();
+  if (!ready) {
+    throw new Error(t('docker.mysqlNotReady'));
+  }
+
+  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();
+    });
+  });
+}
+
+async function runDockerCommand(command, projectRoot = ensureOriginalCwd(), extraArgs = []) {
+  switch (command) {
+    case 'up':
+      startDockerServices(projectRoot);
+      await waitForMysql();
+      return;
+    case 'down':
+      stopDockerServices(projectRoot);
+      return;
+    case 'start':
+      await dockerStartWithDev(projectRoot);
+      return;
+    case 'stop':
+      stopDockerServices(projectRoot);
+      return;
+    case 'restart':
+      stopDockerServices(projectRoot);
+      await new Promise((r) => setTimeout(r, 2000));
+      startDockerServices(projectRoot);
+      await waitForMysql();
+      return;
+    case 'status':
+      execSync('docker-compose -f docker-compose.dev.yml ps', {
+        stdio: 'inherit',
+        cwd: projectRoot,
+      });
+      return;
+    case 'logs': {
+      const service = extraArgs[0] || '';
+      execSync(`docker-compose -f docker-compose.dev.yml logs -f ${service}`.trim(), {
+        stdio: 'inherit',
+        cwd: projectRoot,
+      });
+      return;
+    }
+    default:
+      throw new Error(t('docker.unknownCommand', { command }));
+  }
+}
+
+module.exports = {
+  runDockerCommand,
+  startDockerServices,
+  stopDockerServices,
+  waitForMysql,
+  isDockerRunning,
+};