@fecommunity/reactpress 2.0.0-beta.0 → 3.0.1

package/lib/doctor.js

@@ -0,0 +1,210 @@
+const fs = require('fs');
+const net = require('net');
+const path = require('path');
+const { execSync } = require('child_process');
+const chalk = require('chalk');
+const { getHealthUrl, checkHealth } = require('./http');
+const { isDockerRunning } = require('./docker');
+const { envFileStatus } = require('./status');
+const { t } = require('./i18n');
+
+function checkNodeVersion() {
+  const major = parseInt(process.versions.node.split('.')[0], 10);
+  if (major >= 18) {
+    return { ok: true, message: `Node.js ${process.version}` };
+  }
+  return {
+    ok: false,
+    message: t('doctor.nodeBad', { version: process.version }),
+    fix: t('doctor.nodeFix'),
+  };
+}
+
+function checkDocker() {
+  if (isDockerRunning()) {
+    return { ok: true, message: t('doctor.dockerOk') };
+  }
+  return {
+    ok: false,
+    message: t('doctor.dockerBad'),
+    fix: t('doctor.dockerFix'),
+  };
+}
+
+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;
+}
+
+function checkPort(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(1000, () => {
+      socket.destroy();
+      resolve(false);
+    });
+  });
+}
+
+async function checkPorts(projectRoot) {
+  const env = parseEnv(projectRoot);
+  const apiPort = parseInt(env.SERVER_PORT || '3002', 10);
+  const clientPort = parseInt(env.CLIENT_PORT || '3001', 10);
+  const [apiBusy, clientBusy] = await Promise.all([checkPort(apiPort), checkPort(clientPort)]);
+  const issues = [];
+  if (apiBusy) issues.push(t('doctor.portApiBusy', { port: apiPort }));
+  if (clientBusy) issues.push(t('doctor.portClientBusy', { port: clientPort }));
+  if (issues.length) {
+    return {
+      ok: false,
+      message: issues.join('; '),
+      fix: t('doctor.portFix'),
+    };
+  }
+  return {
+    ok: true,
+    message: t('doctor.portOk', { apiPort, clientPort }),
+  };
+}
+
+async function checkDatabase(projectRoot) {
+  const env = parseEnv(projectRoot);
+  const host = env.DB_HOST || '127.0.0.1';
+  const port = parseInt(env.DB_PORT || '3306', 10);
+  const user = env.DB_USER || 'root';
+  const password = env.DB_PASSWD || env.DB_PASSWORD || 'root';
+  const database = env.DB_DATABASE || 'reactpress';
+
+  return new Promise((resolve) => {
+    let mysql;
+    try {
+      mysql = require('mysql2/promise');
+    } catch {
+      try {
+        mysql = require(path.join(projectRoot, 'server/node_modules/mysql2/promise'));
+      } catch {
+        resolve({
+          ok: false,
+          message: t('doctor.dbNoMysql2'),
+          fix: t('doctor.dbMysql2Fix'),
+        });
+        return;
+      }
+    }
+
+    mysql
+      .createConnection({ host, port, user, password, database, connectTimeout: 5000 })
+      .then(async (conn) => {
+        await conn.ping();
+        await conn.end();
+        resolve({
+          ok: true,
+          message: t('doctor.dbOk', { host, port, database }),
+        });
+      })
+      .catch((err) => {
+        resolve({
+          ok: false,
+          message: t('doctor.dbBad', { error: err.message }),
+          fix: t('doctor.dbFix'),
+        });
+      });
+  });
+}
+
+async function checkApiHealth(projectRoot) {
+  const healthUrl = getHealthUrl(projectRoot);
+  const result = await checkHealth(healthUrl);
+  if (result.ok) {
+    return { ok: true, message: t('doctor.apiOk', { url: healthUrl }) };
+  }
+  return {
+    ok: false,
+    message: t('doctor.apiBad', { url: healthUrl }),
+    fix: t('doctor.apiFix'),
+  };
+}
+
+function checkPnpm() {
+  try {
+    const v = execSync('pnpm -v', { encoding: 'utf8' }).trim();
+    return { ok: true, message: `pnpm ${v}` };
+  } catch {
+    return {
+      ok: false,
+      message: t('doctor.pnpmBad'),
+      fix: t('doctor.pnpmFix'),
+    };
+  }
+}
+
+async function runDoctor(projectRoot) {
+  const env = envFileStatus(projectRoot);
+  const checks = [
+    { name: 'Node.js', run: () => checkNodeVersion() },
+    { name: 'pnpm', run: () => checkPnpm() },
+    {
+      name: t('doctor.check.config'),
+      run: () => ({
+        ok: env.config,
+        message: env.config ? t('doctor.configOk') : t('doctor.configBad'),
+        fix: t('doctor.configFix'),
+      }),
+    },
+    {
+      name: t('doctor.check.env'),
+      run: () => ({
+        ok: env.env,
+        message: env.env ? t('doctor.envOk') : t('doctor.envBad'),
+        fix: t('doctor.envFix'),
+      }),
+    },
+    { name: 'Docker', run: () => checkDocker() },
+    { name: t('doctor.check.ports'), run: () => checkPorts(projectRoot) },
+    { name: t('doctor.check.database'), run: () => checkDatabase(projectRoot) },
+    { name: t('doctor.check.api'), run: () => checkApiHealth(projectRoot) },
+  ];
+
+  console.log('');
+  console.log(chalk.bold.cyan('  ReactPress Doctor'));
+  console.log(chalk.gray(t('doctor.project', { path: projectRoot })));
+  console.log(chalk.gray('  ─────────────────────────────────────'));
+
+  let failed = 0;
+  for (const { name, run } of checks) {
+    const result = await run();
+    const icon = result.ok ? chalk.green('✓') : chalk.red('✗');
+    console.log(`  ${icon} ${chalk.bold(name)}  ${result.message}`);
+    if (!result.ok && result.fix) {
+      console.log(chalk.yellow(`      → ${result.fix}`));
+      failed += 1;
+    } else if (!result.ok) {
+      failed += 1;
+    }
+  }
+
+  console.log(chalk.gray('  ─────────────────────────────────────'));
+  if (failed === 0) {
+    console.log(chalk.green(t('doctor.allPass')));
+  } else {
+    console.log(chalk.yellow(t('doctor.failed', { count: failed })));
+  }
+  console.log('');
+  return failed === 0 ? 0 : 1;
+}
+
+module.exports = { runDoctor };

package/lib/http.js

@@ -0,0 +1,147 @@
+const fs = require('fs');
+const http = require('http');
+const path = require('path');
+
+function loadServerSiteUrl(projectRoot) {
+  const envPath = path.join(projectRoot, '.env');
+  try {
+    const content = fs.readFileSync(envPath, 'utf8');
+    const match = content.match(/^SERVER_SITE_URL=(.+)$/m);
+    if (match) {
+      return match[1].trim().replace(/^['"]|['"]$/g, '');
+    }
+  } catch {
+    // ignore
+  }
+  return 'http://localhost:3002';
+}
+
+function loadClientSiteUrl(projectRoot) {
+  const envPath = path.join(projectRoot, '.env');
+  try {
+    const content = fs.readFileSync(envPath, 'utf8');
+    const match = content.match(/^CLIENT_SITE_URL=(.+)$/m);
+    if (match) {
+      return match[1].trim().replace(/^['"]|['"]$/g, '');
+    }
+  } catch {
+    // ignore
+  }
+  return 'http://localhost:3001';
+}
+
+function getApiPrefix(projectRoot) {
+  const envPath = path.join(projectRoot, '.env');
+  try {
+    const content = fs.readFileSync(envPath, 'utf8');
+    const match = content.match(/^SERVER_API_PREFIX=(.+)$/m);
+    if (match) {
+      return match[1].trim().replace(/^['"]|['"]$/g, '');
+    }
+  } catch {
+    // ignore
+  }
+  return '/api';
+}
+
+function getHealthUrl(projectRoot) {
+  const base = loadServerSiteUrl(projectRoot).replace(/\/$/, '');
+  const prefix = getApiPrefix(projectRoot).replace(/\/$/, '');
+  return `${base}${prefix}/health`;
+}
+
+function checkHealth(url, timeoutMs = 3000) {
+  return new Promise((resolve) => {
+    let parsed;
+    try {
+      parsed = new URL(url);
+    } catch {
+      resolve({ ok: false });
+      return;
+    }
+    const port = parsed.port || (parsed.protocol === 'https:' ? 443 : 80);
+    const req = http.request(
+      {
+        hostname: parsed.hostname,
+        port,
+        path: parsed.pathname + (parsed.search || ''),
+        method: 'GET',
+        timeout: timeoutMs,
+      },
+      (res) => {
+        let body = '';
+        res.on('data', (chunk) => {
+          body += chunk;
+        });
+        res.on('end', () => {
+          const ok = res.statusCode === 200;
+          let data = null;
+          try {
+            data = JSON.parse(body);
+          } catch {
+            // ignore
+          }
+          resolve({ ok, statusCode: res.statusCode, data });
+        });
+      }
+    );
+    req.on('timeout', () => {
+      req.destroy();
+      resolve({ ok: false });
+    });
+    req.on('error', () => resolve({ ok: false }));
+    req.end();
+  });
+}
+
+function isHttpResponding(url, timeoutMs = 2000) {
+  return new Promise((resolve) => {
+    let parsed;
+    try {
+      parsed = new URL(url);
+    } catch {
+      resolve(false);
+      return;
+    }
+
+    const port = parsed.port || (parsed.protocol === 'https:' ? 443 : 80);
+    const req = http.request(
+      {
+        hostname: parsed.hostname,
+        port,
+        path: parsed.pathname || '/',
+        method: 'GET',
+        timeout: timeoutMs,
+      },
+      (res) => resolve(res.statusCode > 0)
+    );
+
+    req.on('timeout', () => {
+      req.destroy();
+      resolve(false);
+    });
+    req.on('error', () => resolve(false));
+    req.end();
+  });
+}
+
+async function waitForHttp(url, timeoutMs = 120_000, intervalMs = 500) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (await isHttpResponding(url)) {
+      return true;
+    }
+    await new Promise((r) => setTimeout(r, intervalMs));
+  }
+  return false;
+}
+
+module.exports = {
+  loadServerSiteUrl,
+  loadClientSiteUrl,
+  getApiPrefix,
+  getHealthUrl,
+  checkHealth,
+  isHttpResponding,
+  waitForHttp,
+};

package/lib/i18n/index.js

@@ -0,0 +1,32 @@
+const { STRINGS } = require('./strings');
+
+function resolveLocale() {
+  const raw = process.env.REACTPRESS_LANG || process.env.LANG || 'en';
+  const code = String(raw).split(/[._-]/)[0].toLowerCase();
+  return code === 'zh' ? 'zh' : 'en';
+}
+
+let locale = resolveLocale();
+
+/**
+ * @param {string} key
+ * @param {Record<string, string | number>} [vars]
+ */
+function t(key, vars = {}) {
+  const table = STRINGS[locale] || STRINGS.en;
+  let text = table[key] ?? STRINGS.en[key] ?? key;
+  for (const [name, value] of Object.entries(vars)) {
+    text = text.replace(new RegExp(`\\{${name}\\}`, 'g'), String(value));
+  }
+  return text;
+}
+
+function getLocale() {
+  return locale;
+}
+
+function setLocale(next) {
+  locale = next === 'zh' ? 'zh' : 'en';
+}
+
+module.exports = { t, getLocale, setLocale, resolveLocale };