@fecommunity/reactpress 3.7.0 → 4.0.0-beta.0

package/lib/lifecycle.js

@@ -1,190 +0,0 @@
-const { spawn } = require('child_process');
-const ora = require('ora');
-const { ensureProjectEnvironment } = require('./bootstrap');
-const { loadServerSiteUrl, waitForHttp } = require('./http');
-const {
-  getServerBin,
-  getServerDir,
-  isUsingMonorepoServer,
-  canStartLocalApi,
-  getPidFile,
-} = require('./paths');
-const net = require('net');
-const { readPid, isProcessRunning, clearPidFile, writePid } = require('./process');
-const { ensureOriginalCwd } = require('./root');
-const { t } = require('./i18n');
-
-function parseServerPort(projectRoot) {
-  try {
-    const url = new URL(loadServerSiteUrl(projectRoot));
-    return Number(url.port) || 3002;
-  } catch {
-    return 3002;
-  }
-}
-
-function isPortBusy(port, host = '127.0.0.1') {
-  return new Promise((resolve) => {
-    const socket = net.createConnection({ port, host }, () => {
-      socket.destroy();
-      resolve(true);
-    });
-    socket.on('error', () => resolve(false));
-    socket.setTimeout(800, () => {
-      socket.destroy();
-      resolve(false);
-    });
-  });
-}
-
-async function waitForPortFree(port, timeoutMs = 8000) {
-  const deadline = Date.now() + timeoutMs;
-  while (Date.now() < deadline) {
-    if (!(await isPortBusy(port))) return true;
-    await new Promise((r) => setTimeout(r, 200));
-  }
-  return false;
-}
-
-async function ensureConfig(projectRoot) {
-  try {
-    await ensureProjectEnvironment(projectRoot);
-    return true;
-  } catch (err) {
-    console.error(t('dev.envFailed'), err.message || err);
-    return false;
-  }
-}
-
-function stopApi(projectRoot) {
-  const pid = readPid(projectRoot);
-  if (pid && isProcessRunning(pid)) {
-    try {
-      process.kill(pid, 'SIGTERM');
-      console.log(t('lifecycle.apiStopped', { pid }));
-    } catch (err) {
-      console.warn(t('lifecycle.stopPidFailed', { pid }), err.message);
-    }
-  }
-  clearPidFile(projectRoot);
-}
-
-async function startApi(projectRoot, { wait = true } = {}) {
-  if (!(await ensureConfig(projectRoot))) {
-    return 1;
-  }
-
-  const existing = readPid(projectRoot);
-  if (existing && isProcessRunning(existing)) {
-    console.log(t('lifecycle.apiAlreadyRunning', { pid: existing }));
-    return 0;
-  }
-  clearPidFile(projectRoot);
-
-  if (!canStartLocalApi(projectRoot)) {
-    console.error(t('lifecycle.noServerAvailable'));
-    return 1;
-  }
-
-  if (isUsingMonorepoServer(projectRoot)) {
-    console.log(t('lifecycle.startingLocalApi'));
-  } else {
-    console.log(t('lifecycle.startingBundledApi'));
-  }
-
-  const child = spawn(process.execPath, [getServerBin(projectRoot)], {
-    cwd: getServerDir(projectRoot),
-    detached: true,
-    stdio: 'ignore',
-    env: {
-      ...process.env,
-      REACTPRESS_ORIGINAL_CWD: projectRoot,
-    },
-  });
-
-  child.unref();
-  writePid(projectRoot, child.pid);
-  console.log(t('lifecycle.apiStartedBg', { pid: child.pid }));
-
-  if (!wait) {
-    return 0;
-  }
-
-  const serverUrl = loadServerSiteUrl(projectRoot);
-  const spinner = ora({
-    text: t('dev.waitingApi', { url: serverUrl }),
-    color: 'magenta',
-    spinner: 'dots',
-  }).start();
-  const ready = await waitForHttp(serverUrl);
-  if (!ready) {
-    spinner.fail(t('lifecycle.apiTimeout120', { url: serverUrl }));
-    return 1;
-  }
-  spinner.succeed(t('lifecycle.apiReady', { url: serverUrl }));
-  return 0;
-}
-
-async function statusApi(projectRoot) {
-  const pid = readPid(projectRoot);
-  const serverUrl = loadServerSiteUrl(projectRoot);
-  const { isHttpResponding } = require('./http');
-  const httpOk = await isHttpResponding(serverUrl);
-
-  const source = isUsingMonorepoServer(projectRoot)
-    ? t('lifecycle.source.monorepo')
-    : t('lifecycle.source.bundle');
-
-  console.log(t('lifecycle.apiStatusTitle'));
-  console.log(t('lifecycle.source', { source }));
-  console.log(t('lifecycle.pidFile', { path: getPidFile(projectRoot) }));
-  console.log(
-    t('lifecycle.recordedPid', {
-      pid: pid ?? t('common.none'),
-    })
-  );
-  console.log(
-    t('lifecycle.processAlive', {
-      alive: pid
-        ? isProcessRunning(pid)
-          ? t('common.yes')
-          : t('common.no')
-        : '—',
-    })
-  );
-  console.log(
-    t('lifecycle.httpStatus', {
-      url: serverUrl,
-      status: httpOk ? t('lifecycle.httpReachable') : t('lifecycle.httpUnreachable'),
-    })
-  );
-}
-
-async function runLifecycleCommand(command, projectRoot = ensureOriginalCwd()) {
-  switch (command) {
-    case 'start':
-      return startApi(projectRoot, { wait: true });
-    case 'start:bg':
-      return startApi(projectRoot, { wait: false });
-    case 'stop':
-      stopApi(projectRoot);
-      return 0;
-    case 'restart':
-      stopApi(projectRoot);
-      await waitForPortFree(parseServerPort(projectRoot));
-      await new Promise((r) => setTimeout(r, 400));
-      return startApi(projectRoot, { wait: true });
-    case 'status':
-      await statusApi(projectRoot);
-      return 0;
-    default:
-      throw new Error(t('lifecycle.unknownCommand', { command }));
-  }
-}
-
-module.exports = {
-  startApi,
-  stopApi,
-  statusApi,
-  runLifecycleCommand,
-};

package/lib/nginx.js

@@ -1,342 +0,0 @@
-const fs = require('fs');
-const path = require('path');
-const http = require('http');
-const { spawnSync } = require('child_process');
-const open = require('open');
-const { detectProjectType } = require('./project-type');
-const { isDockerRunning, pickDockerComposeCommand } = require('./docker');
-const { t } = require('./i18n');
-
-const NGINX_CONTAINER = 'reactpress_nginx';
-const DEFAULT_NGINX_PORT = 80;
-
-function resolveNginxMode(options = {}) {
-  return options.prod ? 'prod' : 'dev';
-}
-
-function resolveNginxConfigBasename(mode) {
-  return mode === 'prod' ? 'nginx.conf' : 'nginx.dev.conf';
-}
-
-function resolveNginxConfigPath(projectRoot, mode = 'dev') {
-  const basename = resolveNginxConfigBasename(mode);
-  const type = detectProjectType(projectRoot);
-  if (type === 'monorepo') {
-    return path.join(projectRoot, basename);
-  }
-  return path.join(projectRoot, '.reactpress', basename);
-}
-
-function bundledTemplatePath(mode) {
-  const file = mode === 'prod' ? 'nginx.prod.conf' : 'nginx.dev.conf';
-  return path.join(__dirname, '..', 'templates', file);
-}
-
-function resolveNginxPort(projectRoot) {
-  const envPath = path.join(projectRoot, '.env');
-  try {
-    const content = fs.readFileSync(envPath, 'utf8');
-    const m = content.match(/^NGINX_PORT=(.+)$/m);
-    if (m) {
-      const port = parseInt(m[1].trim().replace(/^['"]|['"]$/g, ''), 10);
-      if (port > 0) return port;
-    }
-  } catch {
-    // ignore
-  }
-  return DEFAULT_NGINX_PORT;
-}
-
-function nginxEntryUrl(projectRoot) {
-  const port = resolveNginxPort(projectRoot);
-  return port === 80 ? 'http://localhost' : `http://localhost:${port}`;
-}
-
-/**
- * Write default nginx config from CLI templates when missing (or when force).
- *
- * @returns {{ configPath: string, created: boolean, mode: 'dev' | 'prod' }}
- */
-function ensureNginxConfig(projectRoot, options = {}) {
-  const mode = resolveNginxMode(options);
-  const configPath = resolveNginxConfigPath(projectRoot, mode);
-  const templatePath = bundledTemplatePath(mode);
-  if (!fs.existsSync(templatePath)) {
-    throw new Error(t('nginx.templateMissing', { path: templatePath }));
-  }
-
-  const exists = fs.existsSync(configPath);
-  if (exists && !options.force) {
-    return { configPath, created: false, mode };
-  }
-
-  fs.mkdirSync(path.dirname(configPath), { recursive: true });
-  fs.copyFileSync(templatePath, configPath);
-  return { configPath, created: !exists || !!options.force, mode };
-}
-
-function resolveNginxComposeContext(projectRoot, mode = 'dev') {
-  const type = detectProjectType(projectRoot);
-  if (mode === 'prod' && type === 'monorepo') {
-    return {
-      composeFile: path.join(projectRoot, 'docker-compose.prod.yml'),
-      cwd: projectRoot,
-      service: 'nginx',
-    };
-  }
-  if (type === 'monorepo') {
-    return {
-      composeFile: path.join(projectRoot, 'docker-compose.dev.yml'),
-      cwd: projectRoot,
-      service: 'nginx',
-    };
-  }
-  return {
-    composeFile: path.join(projectRoot, '.reactpress', 'docker-compose.yml'),
-    cwd: path.join(projectRoot, '.reactpress'),
-    service: 'nginx',
-  };
-}
-
-function composeDefinesNginxService(composeFile) {
-  try {
-    const content = fs.readFileSync(composeFile, 'utf8');
-    return /^\s*nginx:\s*$/m.test(content);
-  } catch {
-    return false;
-  }
-}
-
-function runComposeOnContext(ctx, args, options = {}) {
-  const { command, baseArgs } = pickDockerComposeCommand();
-  return spawnSync(command, [...baseArgs, '-f', ctx.composeFile, ...args], {
-    stdio: options.stdio ?? 'inherit',
-    cwd: ctx.cwd,
-    ...options,
-  });
-}
-
-function isNginxContainerRunning() {
-  const res = spawnSync(
-    'docker',
-    ['inspect', '-f', '{{.State.Running}}', NGINX_CONTAINER],
-    { encoding: 'utf8' }
-  );
-  return res.status === 0 && res.stdout.trim() === 'true';
-}
-
-function startNginxContainer(configPath, port) {
-  spawnSync('docker', ['rm', '-f', NGINX_CONTAINER], { stdio: 'ignore' });
-  const absConfig = path.resolve(configPath);
-  const res = spawnSync(
-    'docker',
-    [
-      'run',
-      '-d',
-      '--name',
-      NGINX_CONTAINER,
-      '-p',
-      `${port}:80`,
-      '-v',
-      `${absConfig}:/etc/nginx/conf.d/default.conf:ro`,
-      '--add-host',
-      'host.docker.internal:host-gateway',
-      'nginx:alpine',
-    ],
-    { encoding: 'utf8' }
-  );
-  if (res.status !== 0) {
-    throw new Error(res.stderr?.trim() || t('nginx.startFailed'));
-  }
-}
-
-function stopNginxContainer() {
-  spawnSync('docker', ['rm', '-sf', NGINX_CONTAINER], { stdio: 'ignore' });
-}
-
-function nginxUp(projectRoot, options = {}) {
-  if (!isDockerRunning()) {
-    throw new Error(t('docker.notRunning'));
-  }
-
-  const mode = resolveNginxMode(options);
-  const type = detectProjectType(projectRoot);
-
-  if (mode === 'prod' && type !== 'monorepo') {
-    throw new Error(t('nginx.prodMonorepoOnly'));
-  }
-
-  const { configPath } = ensureNginxConfig(projectRoot, { mode, force: options.force });
-  const port = resolveNginxPort(projectRoot);
-  const ctx = resolveNginxComposeContext(projectRoot, mode);
-
-  if (fs.existsSync(ctx.composeFile) && composeDefinesNginxService(ctx.composeFile)) {
-    const result = runComposeOnContext(ctx, ['up', '-d', ctx.service]);
-    if (result.status !== 0) {
-      throw new Error(t('nginx.startFailed'));
-    }
-  } else {
-    startNginxContainer(configPath, port);
-  }
-
-  console.log(t('nginx.started', { url: nginxEntryUrl(projectRoot) }));
-  console.log(t('nginx.configPath', { path: configPath }));
-}
-
-function nginxDown(projectRoot, options = {}) {
-  const mode = resolveNginxMode(options);
-  const ctx = resolveNginxComposeContext(projectRoot, mode);
-  if (fs.existsSync(ctx.composeFile) && composeDefinesNginxService(ctx.composeFile)) {
-    runComposeOnContext(ctx, ['stop', ctx.service], { stdio: 'ignore' });
-  }
-  stopNginxContainer();
-  console.log(t('nginx.stopped'));
-}
-
-function nginxRestart(projectRoot, options = {}) {
-  nginxDown(projectRoot, options);
-  nginxUp(projectRoot, options);
-}
-
-function nginxStatus(projectRoot, options = {}) {
-  const mode = resolveNginxMode(options);
-  const configPath = resolveNginxConfigPath(projectRoot, mode);
-  const port = resolveNginxPort(projectRoot);
-  const running = isNginxContainerRunning();
-  const configExists = fs.existsSync(configPath);
-
-  console.log(t('nginx.statusTitle'));
-  console.log(t('nginx.statusContainer', { name: NGINX_CONTAINER, running: running ? t('common.yes') : t('common.no') }));
-  console.log(t('nginx.statusConfig', { path: configPath, exists: configExists ? t('common.yes') : t('common.no') }));
-  console.log(t('nginx.statusUrl', { url: nginxEntryUrl(projectRoot), port }));
-  console.log(t('nginx.statusMode', { mode }));
-}
-
-function nginxLogs(extraArgs = []) {
-  const args = ['logs', '-f', NGINX_CONTAINER, ...extraArgs];
-  spawnSync('docker', args, { stdio: 'inherit' });
-}
-
-function dockerExecNginx(args) {
-  return spawnSync('docker', ['exec', NGINX_CONTAINER, 'nginx', ...args], {
-    encoding: 'utf8',
-  });
-}
-
-function nginxTest() {
-  if (!isNginxContainerRunning()) {
-    throw new Error(t('nginx.notRunning'));
-  }
-  const res = dockerExecNginx(['-t']);
-  process.stdout.write(res.stdout || '');
-  process.stderr.write(res.stderr || '');
-  if (res.status !== 0) {
-    throw new Error(t('nginx.testFailed'));
-  }
-  console.log(t('nginx.testOk'));
-}
-
-function nginxReload() {
-  nginxTest();
-  const res = dockerExecNginx(['-s', 'reload']);
-  if (res.status !== 0) {
-    throw new Error(res.stderr?.trim() || t('nginx.reloadFailed'));
-  }
-  console.log(t('nginx.reloadOk'));
-}
-
-async function nginxOpen(projectRoot) {
-  const url = nginxEntryUrl(projectRoot);
-  console.log(t('nginx.opening', { url }));
-  await open(url);
-}
-
-function probeNginxHealth(projectRoot, timeoutMs = 2000) {
-  const url = new URL('/health', nginxEntryUrl(projectRoot));
-  return new Promise((resolve) => {
-    const req = http.get(url, { timeout: timeoutMs }, (res) => {
-      res.resume();
-      resolve(res.statusCode === 200);
-    });
-    req.on('error', () => resolve(false));
-    req.on('timeout', () => {
-      req.destroy();
-      resolve(false);
-    });
-  });
-}
-
-async function checkNginx(projectRoot) {
-  if (!isDockerRunning()) {
-    return { ok: true, message: t('nginx.doctorSkippedDocker') };
-  }
-  if (!isNginxContainerRunning()) {
-    return { ok: true, message: t('nginx.doctorSkippedNotRunning') };
-  }
-  const healthy = await probeNginxHealth(projectRoot);
-  if (healthy) {
-    return {
-      ok: true,
-      message: t('nginx.doctorOk', { url: nginxEntryUrl(projectRoot) }),
-    };
-  }
-  return {
-    ok: false,
-    message: t('nginx.doctorUnhealthy', { url: nginxEntryUrl(projectRoot) }),
-    fix: t('nginx.doctorUnhealthyFix'),
-  };
-}
-
-async function runNginxCommand(command, projectRoot, extraArgs = [], options = {}) {
-  switch (command) {
-    case 'ensure': {
-      const { configPath, created } = ensureNginxConfig(projectRoot, options);
-      console.log(
-        created ? t('nginx.configCreated', { path: configPath }) : t('nginx.configExists', { path: configPath })
-      );
-      return;
-    }
-    case 'up':
-      nginxUp(projectRoot, options);
-      return;
-    case 'down':
-    case 'stop':
-      nginxDown(projectRoot, options);
-      return;
-    case 'restart':
-      nginxRestart(projectRoot, options);
-      return;
-    case 'status':
-      nginxStatus(projectRoot, options);
-      return;
-    case 'logs':
-      nginxLogs(extraArgs);
-      return;
-    case 'test':
-      nginxTest();
-      return;
-    case 'reload':
-      nginxReload();
-      return;
-    case 'open':
-      await nginxOpen(projectRoot);
-      return;
-    default:
-      throw new Error(t('nginx.unknownCommand', { command }));
-  }
-}
-
-module.exports = {
-  NGINX_CONTAINER,
-  DEFAULT_NGINX_PORT,
-  resolveNginxMode,
-  resolveNginxConfigPath,
-  resolveNginxComposeContext,
-  ensureNginxConfig,
-  nginxEntryUrl,
-  resolveNginxPort,
-  isNginxContainerRunning,
-  probeNginxHealth,
-  checkNginx,
-  runNginxCommand,
-};

package/lib/paths.js

@@ -1,108 +0,0 @@
-const fs = require('fs');
-const path = require('path');
-const { ensureOriginalCwd, getMonorepoRoot } = require('./root');
-
-function resolveProjectRoot(projectRoot) {
-  return path.resolve(projectRoot || ensureOriginalCwd());
-}
-
-function getMonorepoServerDir(projectRoot) {
-  return path.join(resolveProjectRoot(projectRoot), 'server');
-}
-
-function hasMonorepoServerSource(projectRoot) {
-  return fs.existsSync(
-    path.join(getMonorepoServerDir(projectRoot), 'src', 'main.ts')
-  );
-}
-
-function getCliPackageRoot() {
-  const ownRoot = path.join(__dirname, '..');
-  if (fs.existsSync(path.join(ownRoot, 'dist', 'index.js'))) {
-    return ownRoot;
-  }
-  try {
-    return path.dirname(
-      require.resolve('@fecommunity/reactpress-cli-core/package.json')
-    );
-  } catch {
-    return path.dirname(require.resolve('@fecommunity/reactpress-cli/package.json'));
-  }
-}
-
-function getBundledServerDir() {
-  return path.join(getCliPackageRoot(), 'server');
-}
-
-function hasBundledServerBuild() {
-  return fs.existsSync(path.join(getBundledServerDir(), 'dist', 'main.js'));
-}
-
-function getServerDir(projectRoot) {
-  if (hasMonorepoServerSource(projectRoot)) {
-    return getMonorepoServerDir(projectRoot);
-  }
-  return getBundledServerDir();
-}
-
-function getServerBin(projectRoot) {
-  return path.join(getServerDir(projectRoot), 'bin', 'reactpress-server.js');
-}
-
-function getSwaggerPath(projectRoot) {
-  return path.join(getServerDir(projectRoot), 'public', 'swagger.json');
-}
-
-function getServerMain(projectRoot) {
-  return path.join(getServerDir(projectRoot), 'dist', 'main.js');
-}
-
-function isUsingMonorepoServer(projectRoot) {
-  return hasMonorepoServerSource(projectRoot);
-}
-
-function canStartLocalApi(projectRoot) {
-  return (
-    isUsingMonorepoServer(projectRoot) ||
-    hasBundledServerBuild()
-  );
-}
-
-function getClientBin(projectRoot) {
-  const binPath = path.join(
-    resolveProjectRoot(projectRoot),
-    'client',
-    'bin',
-    'reactpress-client.js'
-  );
-  if (!fs.existsSync(binPath)) {
-    const err = new Error(
-      `Client entry not found: ${binPath}. Run from a ReactPress monorepo root or use reactpress dev --client-only with a remote API.`
-    );
-    err.code = 'REACTPRESS_CLIENT_NOT_FOUND';
-    throw err;
-  }
-  return binPath;
-}
-
-function getPidFile(projectRoot) {
-  return path.join(resolveProjectRoot(projectRoot), '.reactpress', 'server.pid');
-}
-
-module.exports = {
-  getMonorepoRoot,
-  resolveProjectRoot,
-  getMonorepoServerDir,
-  hasMonorepoServerSource,
-  hasBundledServerBuild,
-  isUsingMonorepoServer,
-  canStartLocalApi,
-  getCliPackageRoot,
-  getBundledServerDir,
-  getServerDir,
-  getServerBin,
-  getSwaggerPath,
-  getServerMain,
-  getClientBin,
-  getPidFile,
-};

package/lib/pm2.js

@@ -1,32 +0,0 @@
-const { spawn } = require('child_process');
-const { getServerBin, getServerDir } = require('./paths');
-const { ensureOriginalCwd } = require('./root');
-const { t } = require('./i18n');
-
-function startApiWithPm2(projectRoot = ensureOriginalCwd()) {
-  return new Promise((resolve, reject) => {
-    const child = spawn(process.execPath, [getServerBin(projectRoot), '--pm2'], {
-      stdio: 'inherit',
-      cwd: getServerDir(projectRoot),
-      env: {
-        ...process.env,
-        REACTPRESS_ORIGINAL_CWD: projectRoot,
-      },
-    });
-
-    child.on('error', (error) => {
-      console.error(t('pm2.startFailed'), error);
-      reject(error);
-    });
-
-    child.on('close', (code) => {
-      if (code !== 0) {
-        reject(Object.assign(new Error(t('pm2.exitCode', { code })), { exitCode: code }));
-        return;
-      }
-      resolve();
-    });
-  });
-}
-
-module.exports = { startApiWithPm2 };

package/lib/process.js

@@ -1,45 +0,0 @@
-const fs = require('fs');
-const path = require('path');
-const { getPidFile } = require('./paths');
-
-function readPid(projectRoot) {
-  const pidFile = getPidFile(projectRoot);
-  try {
-    const raw = fs.readFileSync(pidFile, 'utf8').trim();
-    const pid = Number.parseInt(raw, 10);
-    return Number.isFinite(pid) ? pid : null;
-  } catch {
-    return null;
-  }
-}
-
-function isProcessRunning(pid) {
-  if (!pid) return false;
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-function clearPidFile(projectRoot) {
-  const pidFile = getPidFile(projectRoot);
-  if (fs.existsSync(pidFile)) {
-    fs.unlinkSync(pidFile);
-  }
-}
-
-function writePid(projectRoot, pid) {
-  const pidFile = getPidFile(projectRoot);
-  fs.mkdirSync(path.dirname(pidFile), { recursive: true });
-  fs.writeFileSync(pidFile, String(pid));
-}
-
-module.exports = {
-  readPid,
-  isProcessRunning,
-  clearPidFile,
-  writePid,
-  getPidFile,
-};