cangku/backend/src/index.js
yanhui 2defbe9192 perf(mkh-bom): 把订单全表扫挪出请求路径,页面不再每次打开都等分钟级冷查
现象:MKH-BOM 每次打开 / F5 / 每 2 分钟轮询都要等 2 分钟以上,导出明细也卡,
且页面长期处于 pendingOrderDegraded(待发 SKU = 0、订单驱动预警 = 0)。

2026-11-17 生产容器实测:rpt.jst_Orders 158 万行光 COUNT(*) 需 152.8s(≈1 万行/秒),
loadOrderIndex 单跑 408.5s 后降级;首屏冷查 126.9s,而缓存命中只要 4.2s。

四处根因与对应修复:

1) `{ requestTimeout: 180000 }` 在 query() 上不生效(只写请求级 request.timeout,
   mssql 12.x 无效)→ 实际按共享池 60s 掐断 → 每次加载都降级。
   cloudDatabase.query 新增 `freshConnection: true`:委派到既有 queryWithFreshConnection
   (独立连接,池级超时随 connectRequestTimeoutMs 放大);不传时行为不变。
   订单两表 + 出库校验改走该路径,分别 300s / 180s,maxAttempts 1(慢库重试只是把等待翻倍)。
2) 降级缓存 60s → 5 分钟:降级态每次重试都是一次全表扫,60s 等于「刚失败就重打」的自残循环。
3) 订单索引 TTL 10 → 30 分钟,并改为 stale-while-revalidate:过期后先返回旧快照、
   后台补新值(后台失败则保留旧索引并压 60 秒再试,不再把缓存清成 null 让待发货量显示 0)。
   新增 jobs/mkhBomPrewarmJob:启动 20s 后 + 每 20 分钟后台预热(间隔可用环境变量调)。
4) 前端首屏 / 轮询不再发 fresh=1(它会让后端清缓存 → 必冷查);
   强制重读只保留「同步最新数据 / 刷新数据」按钮一个入口。
5) 待发货分支补 order_date >= 近 180 天下界,不再让历史僵尸单参与扫描与累计
   (order_date 为空照旧纳入,宁可多算不漏算)。

验证:backend syntax 197 文件通过;backend test 526/524 pass(2 个既有环境失败:
13333 隧道未起、Windows chmod);mkhBomService 61/61,含新增 5 条针对本次改动的用例;
frontend eslint 无告警、npm run build 通过。

口径提示:第 5 条会改变「待发货订单量」的统计范围(只算近 180 天下单),需业务确认;
若半年以上确有待发单,改 PENDING_ORDER_MAX_AGE_DAYS 一行即可。
2026-11-17 10:24:36 +08:00

972 lines
36 KiB
JavaScript
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

// 后端服务入口
const path = require('path');
require('dotenv').config();
require('dotenv').config({ path: path.resolve(__dirname, '../.env') });
const express = require('express');
const cors = require('cors');
const { CubejsServer } = require('@cubejs-backend/server');
const mysql = require('mysql2/promise');
const installRoutes = require('./api/install');
const authMiddleware = require('./middleware/auth');
const { createPageDataCache } = require('./middleware/pageDataCache');
const adminRoutes = require('./api/admin');
const planningUploadRoutes = require('./api/planningUpload');
const planningMayProductPublicRoutes = require('./api/planningMayProductPublic');
const planningSelectionFissionExternalRoutes = require('./api/planningSelectionFissionExternal');
const presaleExternalRoutes = require('./api/presaleExternal');
const delistExternalRoutes = require('./api/delistExternal');
const campaignCloudRoutes = require('./api/campaignCloud');
const desktopClientRoutes = require('./api/desktopClient');
const desktopPresenceRoutes = require('./api/desktopPresence');
const desktopExecutionTaskRoutes = require('./api/desktopExecutionTasks');
const alibaba1688ProductExternalRoutes = require('./api/alibaba1688ProductExternal');
const taobaoDetailPlusRoutes = require('./api/taobaoDetailPlus');
const thirdPartySsoRoutes = require('./api/thirdPartySso');
const thirdPartySsoAdminRoutes = require('./api/thirdPartySsoAdmin');
const channelRoutes = require('./api/channel');
const analysisRoutes = require('./api/analysis');
const productCodeBoardRoutes = require('./api/productCodeBoard');
const productAnalysisRoutes = require('./api/productAnalysis');
const marketingEventsRoutes = require('./api/marketingEvents');
const promotionModuleRoutes = require('./api/promotionModule');
const productMonitoringRoutes = require('./api/productMonitoring');
const modularStockMonitorRoutes = require('./api/modularStockMonitor');
const mkhBomRoutes = require('./api/mkhBom');
const warehouseShipTimelinessRoutes = require('./api/warehouseShipTimeliness');
const warehouseLogisticsExceptionRoutes = require('./api/warehouseLogisticsException');
const dailyInventoryRoutes = require('./api/dailyInventory');
const dailyInventoryNotificationRoutes = require('./api/dailyInventoryNotification');
const stockSalesAnalysisRoutes = require('./api/stockSalesAnalysis');
const pickingBinSalesAnalysisRoutes = require('./api/pickingBinSalesAnalysis');
const binReplenishRoutes = require('./api/binReplenish');
const returnInventoryWarningRoutes = require('./api/returnInventoryWarning');
const returnMonitorRoutes = require('./api/returnMonitor');
const returnStockWarningRoutes = require('./api/returnStockWarning');
const database = require('./config/database');
const cloudDb = require('./config/cloudDatabase');
const jianSunDb = require('./config/jianSunDatabase');
const redis = require('./config/redis');
const { startScheduler, manualRefresh } = require('./jobs/dailyRefresh');
const { startStockSelectionSchedulers } = require('./jobs/stockSelectionSyncJob');
const { startTaobaoProductEmbeddingSchedulers } = require('./jobs/taobaoProductEmbeddingSyncJob');
const { startPddSkuDimensionSnapshotSchedulers } = require('./jobs/pddSkuDimensionSnapshotJob');
const { startPlanningMayProductSnapshotSchedulers } = require('./jobs/planningMayProductSnapshotJob');
const { startPlanningDingWorkflowSyncSchedulers } = require('./jobs/planningDingWorkflowSyncJob');
const { startOpsBIncentiveSnapshotSchedulers } = require('./jobs/opsBIncentiveSnapshotJob');
const { startGoodsFirstSeenScheduler } = require('./jobs/goodsFirstSeenJob');
const {
startDailyInventorySnapshotScheduler,
} = require('./jobs/dailyInventorySnapshotJob');
const {
startDailyInventoryNotificationScheduler,
} = require('./jobs/dailyInventoryNotificationJob');
const {
startAlibaba1688ImageSearchExpiryScheduler,
} = require('./jobs/alibaba1688ImageSearchExpiryJob');
const {
startMkhReplenishAlertScheduler,
} = require('./jobs/mkhReplenishAlertJob');
const {
startMkhBomPrewarmScheduler,
} = require('./jobs/mkhBomPrewarmJob');
const {
startWarehouseLogisticsExceptionNotifyScheduler,
} = require('./jobs/warehouseLogisticsExceptionNotifyJob');
const {
startShipTimelinessNotifyScheduler,
} = require('./jobs/warehouseShipTimelinessNotifyJob');
const { DEFAULT_SITE_CONFIG, getInstallStatus } = require('./services/installService');
const { ensureLocalSchema } = require('./services/localSchema');
const {
prewarmChannelHotData,
prewarmChannelIdDefaultSnapshots,
prewarmChannelIdDashboardDefaultSnapshot,
prewarmChannelStockMonitorDashboardDefaultSnapshot,
} = require('./services/channelAnalysis');
const { prewarmBrandAnalysisDefault } = require('./services/brandAnalysis');
const { runHeavyDatabaseTask } = require('./services/databaseLoadGuard');
const { warmSelectionFissionReadSchema } = require('./services/planningSelectionFissionService');
const {
getPublicSystemConfigCache,
getStalePublicSystemConfigCache,
setPublicSystemConfigCache,
} = require('./services/publicSystemConfigCache');
const { filterPublicSystemConfigs } = require('./services/systemConfigVisibility');
const {
shouldRequireImageSearchCredentials,
verifyImageSearchCredentials,
} = require('./services/imageSearchCredentialGuard');
const PLANNING_PAGE_REDIS_TTL_SECONDS = Math.max(
Number(process.env.PLANNING_PAGE_RESPONSE_CACHE_REDIS_TTL_SECONDS) || 23 * 60 * 60,
60
);
const BRAND_ANALYSIS_PREWARM_DELAY_MS = Math.max(
Number(process.env.BRAND_ANALYSIS_PREWARM_DELAY_MS) || 20 * 1000,
5 * 1000
);
const PUBLIC_SYSTEM_CONFIG_CACHE_TTL_MS = Math.max(
Number(process.env.PUBLIC_SYSTEM_CONFIG_CACHE_TTL_SECONDS) || 300,
30
) * 1000;
const PUBLIC_SYSTEM_CONFIG_QUERY_TIMEOUT_MS = Math.max(
Number(process.env.PUBLIC_SYSTEM_CONFIG_QUERY_TIMEOUT_MS) || 1800,
500
);
const CUBE_SCHEDULED_REFRESH_TIMER = String(process.env.CUBEJS_SCHEDULED_REFRESH_TIMER || '')
.trim()
.toLowerCase() === 'true';
function getBuildIdentity() {
return {
sourceGitSha: String(process.env.SOURCE_GIT_SHA || '').trim() || null,
sourceGitRef: String(process.env.SOURCE_GIT_REF || '').trim() || null,
};
}
const CHANNEL_STOCK_MONITOR_RESILIENCE_PREWARM_DELAY_MS = Math.max(
Number(process.env.CHANNEL_STOCK_MONITOR_RESILIENCE_PREWARM_DELAY_MS) || 90000,
10000
);
const CHANNEL_ID_RESILIENCE_PREWARM_DELAY_MS = Math.max(
Number(process.env.CHANNEL_ID_RESILIENCE_PREWARM_DELAY_MS) || 30000,
10000
);
function shouldCachePlanningUploadResponse(body = {}) {
if (!body || body.error || body.success === false) {
return false;
}
const payload = body.data || body;
if (payload?.pending || payload?.cache?.backgroundRefresh) {
return false;
}
return true;
}
function shouldHandlePlanningUploadPageCache(req) {
// 企划页首页会聚合 MAY 快照统计;MAY 商品页本身也依赖最新成功批次。
// MAY 渠道洞察也依赖最新店铺/覆盖快照,外层整页缓存会把旧列口径整天顶住。
// 榜单数据分析现在也依赖实时机会/竞争诊断结果,外层整页缓存会把旧字段结构整天顶住。
// 抖音/小红书市场页支持实时批次切换,整页缓存会把旧批次和旧字段结构顶住。
// 这些接口必须直接读实体表/轻缓存,不能再被 23 小时整页 Redis 顶住。
if (
req.path === '/'
|| req.path.startsWith('/table/may_product_data')
|| req.path.startsWith('/analysis/may-channel-insight')
|| req.path.startsWith('/analysis/ops-b-incentive')
|| req.path.startsWith('/selection-fission')
) {
return false;
}
return true;
}
const analysisPageCache = createPageDataCache({
namespace: 'analysis',
redisTtlSeconds: 300,
});
const channelPageCache = createPageDataCache({
namespace: 'channel',
redisTtlSeconds: 300,
// ID 分析内部已有按口径版本控制的缓存;导出接口返回 CSV,不能走整页 JSON 缓存。
shouldHandleRequest: (req) => !['/id-analysis', '/export'].includes(req.path)
&& !req.path.startsWith('/export-jobs'),
});
const planningUploadPageCache = createPageDataCache({
namespace: 'planning-upload',
version: 'v27-bypass-may-snapshot-pages-20260423',
redisTtlSeconds: PLANNING_PAGE_REDIS_TTL_SECONDS,
shouldHandleRequest: shouldHandlePlanningUploadPageCache,
shouldCacheBody: shouldCachePlanningUploadResponse,
});
let serverMode = 'install';
function isStartupPrewarmEnabled() {
return String(process.env.ENABLE_STARTUP_PREWARM || '').toLowerCase() === 'true';
}
function runGuardedPrewarm(label, handler) {
return runHeavyDatabaseTask(`prewarm:${label}`, handler);
}
function withTimeout(promise, timeoutMs, fallback) {
let timer = null;
return Promise.race([
promise.finally(() => {
if (timer) {
clearTimeout(timer);
}
}),
new Promise((resolve) => {
timer = setTimeout(() => resolve(fallback), timeoutMs);
if (typeof timer.unref === 'function') {
timer.unref();
}
}),
]);
}
function hasCompleteCloudEnvConfig() {
return cloudDb.hasCompleteEnvConfig();
}
function getCloudEnvConfig() {
const config = cloudDb.getEnvBusinessDatabaseConfig();
return {
driver: config.driver || 'mssql',
host: config.host,
port: config.port || 1433,
database: config.database,
user: config.user,
password: config.password,
ssl: Boolean(config.ssl),
};
}
function getBootstrapCloudConfig() {
return {
driver: 'mysql',
host: process.env.LOCAL_DB_HOST,
port: parseInt(process.env.LOCAL_DB_PORT || '3306', 10),
database: process.env.LOCAL_DB_NAME,
user: process.env.LOCAL_DB_USER,
password: process.env.LOCAL_DB_PASSWORD,
ssl: false,
bootstrap: true,
};
}
// =====================
// 从数据库获取云数据库配置
// =====================
async function getCloudDbConfig() {
let localPool;
try {
// 先连接本地数据库读取配置
localPool = mysql.createPool({
host: process.env.LOCAL_DB_HOST,
port: parseInt(process.env.LOCAL_DB_PORT || '3306'),
user: process.env.LOCAL_DB_USER,
password: process.env.LOCAL_DB_PASSWORD,
database: process.env.LOCAL_DB_NAME,
charset: 'utf8mb4',
waitForConnections: true,
connectionLimit: 2,
maxIdle: 2,
idleTimeout: 60000,
queueLimit: 10,
connectTimeout: 5000,
enableKeepAlive: true,
keepAliveInitialDelay: 0,
});
const [rows] = await localPool.query(
'SELECT host, port, database_name, username, password, `ssl`, driver, use_env_config FROM database_configs WHERE is_default = 1 AND status = ? LIMIT 1',
['active']
);
if (rows.length > 0) {
const config = rows[0];
if (config.use_env_config === 1 || config.use_env_config === true) {
if (hasCompleteCloudEnvConfig()) {
console.log('📌 使用 .env 业务数据库配置(CLOUD_DB_*)');
return getCloudEnvConfig();
}
console.warn('⚠️ 已开启 .env 业务数据库配置,但 CLOUD_DB_* 不完整,继续使用 database_configs 表配置');
}
console.log('📌 使用数据库配置(来自 database_configs 表)');
return {
driver: config.driver || 'mysql',
host: config.host,
port: config.port || 3306,
database: config.database_name,
user: config.username,
password: config.password,
ssl: config.ssl === 1,
};
}
} catch (error) {
console.warn('⚠️ 无法从数据库读取配置:', error.message);
} finally {
if (localPool) {
await localPool.end().catch((error) => {
console.warn('⚠️ 关闭系统库临时连接池失败:', error.message);
});
}
}
// 回退到环境变量配置
if (hasCompleteCloudEnvConfig()) {
console.log('📌 使用环境变量配置(CLOUD_DB_*)');
return getCloudEnvConfig();
}
console.log('⚙️ 业务数据库尚未配置,已进入系统初始化模式');
return getBootstrapCloudConfig();
}
function applyCommonMiddleware(app) {
app.set('trust proxy', 1);
app.use(cors());
app.use(express.json({
limit: '15mb',
verify: (req, _res, buffer) => {
req.rawBody = buffer.toString('utf8');
},
}));
}
function registerPublicSystemConfigRoute(app, fallbackConfig = DEFAULT_SITE_CONFIG) {
app.get('/api/admin/system-config', async (_req, res) => {
const now = Date.now();
const cachedConfig = getPublicSystemConfigCache(now);
if (cachedConfig) {
return res.json(cachedConfig);
}
try {
const configs = await Promise.race([
database.local.query('SELECT config_key, config_value, config_type FROM system_config'),
new Promise((_, reject) => {
setTimeout(() => reject(new Error('public system config query timeout')), PUBLIC_SYSTEM_CONFIG_QUERY_TIMEOUT_MS);
}),
]);
const result = {};
filterPublicSystemConfigs(configs).forEach((config) => {
if (config.config_type === 'boolean') {
result[config.config_key] = config.config_value === 'true' || config.config_value === '1';
} else if (config.config_type === 'number') {
result[config.config_key] = Number(config.config_value);
} else {
result[config.config_key] = config.config_value;
}
});
setPublicSystemConfigCache(result, PUBLIC_SYSTEM_CONFIG_CACHE_TTL_MS, now);
res.json(result);
} catch (error) {
const staleConfig = getStalePublicSystemConfigCache();
if (staleConfig) {
return res.json(staleConfig);
}
if (serverMode === 'install' || serverMode === 'database_unavailable') {
return res.json({
site_name: fallbackConfig.siteName,
site_description: fallbackConfig.siteDescription,
logo: '',
});
}
console.warn('获取系统配置超时或失败,返回兜底配置:', error.message);
return res.json({
site_name: fallbackConfig.siteName,
site_description: fallbackConfig.siteDescription,
logo: '',
});
}
});
}
function registerInstallModeRoutes(app, installStatus) {
const unavailableHandler = (_req, res) => {
res.status(503).json({ error: '系统尚未完成安装,请先访问 /install 完成初始化' });
};
app.get('/health', async (_req, res) => {
const status = await getInstallStatus();
res.json({
status: 'install_required',
timestamp: new Date().toISOString(),
build: getBuildIdentity(),
install: status,
});
});
app.use('/api/install', installRoutes);
registerPublicSystemConfigRoute(app);
app.get('/api/auth/providers', (_req, res) => {
res.json({
authBaseUrl: '',
dingtalkEnabled: false,
googleEnabled: false,
installRequired: true,
});
});
app.get('/api/auth/dingtalk/login', unavailableHandler);
app.get('/api/auth/google/login', unavailableHandler);
app.post('/api/auth/login', unavailableHandler);
app.post('/api/auth/callback', unavailableHandler);
app.get('/api/auth/verify', (_req, res) => {
res.status(401).json({ valid: false, installRequired: true });
});
app.use('/api/admin', (_req, res) => {
res.status(503).json({
error: '系统尚未完成安装,请先访问 /install 初始化系统数据库并创建管理员账号',
});
});
console.log('='.repeat(50));
console.log('🛠️ 系统已进入首次安装模式');
console.log(`📡 服务地址: http://localhost:${process.env.PORT || 4000}`);
console.log(`🧭 安装入口: http://localhost:${process.env.PORT || 4000}/install`);
console.log(`📦 安装状态: ${installStatus.systemDatabase.reason}`);
console.log('='.repeat(50));
}
async function startInstallServer(installStatus) {
serverMode = 'install';
const app = express();
applyCommonMiddleware(app);
registerInstallModeRoutes(app, installStatus);
const port = parseInt(process.env.PORT || '4000', 10);
await new Promise((resolve) => {
app.listen(port, resolve);
});
}
function registerDatabaseUnavailableRoutes(app, installStatus) {
const unavailableHandler = (_req, res) => {
res.status(503).json({
error: '系统数据库暂时无法连接,请检查 MySQL 网络、白名单或安全组后重启服务',
databaseUnavailable: true,
installRequired: false,
});
};
app.get('/health', async (_req, res) => {
const status = await getInstallStatus();
res.status(503).json({
status: 'database_unavailable',
timestamp: new Date().toISOString(),
build: getBuildIdentity(),
install: status,
});
});
app.use('/api/install', installRoutes);
registerPublicSystemConfigRoute(app);
app.get('/api/auth/providers', (_req, res) => {
res.json({
authBaseUrl: '',
dingtalkEnabled: false,
googleEnabled: false,
installRequired: false,
databaseUnavailable: true,
});
});
app.get('/api/auth/verify', (_req, res) => {
res.status(503).json({ valid: false, databaseUnavailable: true, installRequired: false });
});
app.post('/api/auth/login', unavailableHandler);
app.post('/api/auth/callback', unavailableHandler);
app.get('/api/auth/dingtalk/login', unavailableHandler);
app.get('/api/auth/google/login', unavailableHandler);
app.use('/api', unavailableHandler);
console.log('='.repeat(50));
console.log('🚧 系统数据库暂时无法连接,已进入降级模式');
console.log(`📡 服务地址: http://localhost:${process.env.PORT || 4000}`);
console.log(`📦 数据库状态: ${installStatus.systemDatabase.reason}`);
console.log('💡 这不是首次安装,请检查 MySQL 白名单/安全组/网络后重启服务');
console.log('='.repeat(50));
}
async function startDatabaseUnavailableServer(installStatus) {
serverMode = 'database_unavailable';
const app = express();
applyCommonMiddleware(app);
registerDatabaseUnavailableRoutes(app, installStatus);
const port = parseInt(process.env.PORT || '4000', 10);
await new Promise((resolve) => {
app.listen(port, resolve);
});
}
async function createFullModeApp(cloudConfig) {
const dbType = cloudConfig.driver === 'mssql' ? 'mssql' : 'mysql';
console.log(`📊 数据库类型: ${dbType}`);
const port = parseInt(process.env.PORT || '4000', 10);
if (String(process.env.DISABLE_CUBEJS || '').trim().toLowerCase() === 'true') {
console.warn('⏸️ 已通过 DISABLE_CUBEJS=true 跳过 Cube.js,仅启动业务 API 服务');
const app = express();
await new Promise((resolve) => {
app.listen(port, resolve);
});
return {
app,
cubeMode: 'disabled',
cubeError: 'DISABLE_CUBEJS=true',
};
}
try {
const cubejsServer = new CubejsServer({
schemaPath: 'model',
dbType: dbType,
logger: (msg, params) => {
console.log(`[Cube.js] ${msg}`, params !== undefined ? JSON.stringify(params) : '');
},
driverFactory: () => {
// 根据 driver 类型选择驱动
if (cloudConfig.driver === 'mssql') {
const MSSQLDriver = require('@cubejs-backend/mssql-driver');
return new MSSQLDriver({
server: cloudConfig.host,
port: cloudConfig.port,
database: cloudConfig.database,
user: cloudConfig.user,
password: cloudConfig.password,
options: {
encrypt: cloudConfig.ssl,
trustServerCertificate: true,
},
});
}
// 默认使用 MySQL
const MySQLDriver = require('@cubejs-backend/mysql-driver');
return new MySQLDriver({
database: cloudConfig.database,
host: cloudConfig.host,
port: cloudConfig.port,
user: cloudConfig.user,
password: cloudConfig.password,
ssl: cloudConfig.ssl,
});
},
apiSecret: process.env.CUBEJS_API_SECRET,
scheduledRefreshTimer: CUBE_SCHEDULED_REFRESH_TIMER,
jwt: {
key: process.env.CUBEJS_SECRET,
algorithms: ['HS256'],
},
});
const { app } = await cubejsServer.listen();
return {
app,
cubeMode: 'cube',
cubeError: null,
};
} catch (error) {
console.warn('⚠️ Cube.js 启动失败,已降级为业务 API 服务:', error.message);
const app = express();
await new Promise((resolve) => {
app.listen(port, resolve);
});
return {
app,
cubeMode: 'express-fallback',
cubeError: error.message,
};
}
}
// =====================
// 启动服务
// =====================
async function startServer(options = {}) {
const envSkipLocalSchema = String(process.env.SKIP_LOCAL_SCHEMA_CHECK || '').trim().toLowerCase() === 'true';
const { skipLocalSchema = envSkipLocalSchema } = options;
serverMode = 'full';
if (skipLocalSchema) {
console.warn('⚠️ 系统数据库暂时不可用,已跳过本次本地 schema 检查,继续启动业务 API');
} else {
await ensureLocalSchema();
}
if (shouldRequireImageSearchCredentials()) {
const credentialStatus = await verifyImageSearchCredentials();
console.log(`✅ 图搜凭据守卫通过:公司=${credentialStatus.company.source}, 1688=${credentialStatus.alibaba1688.source}`);
}
// 获取云数据库配置
const cloudConfig = await getCloudDbConfig();
if (cloudConfig.bootstrap) {
console.log(`📊 初始化模式占位数据源: ${cloudConfig.host}:${cloudConfig.port}/${cloudConfig.database}`);
} else {
console.log(`📊 云数据库: ${cloudConfig.host}:${cloudConfig.port}/${cloudConfig.database}`);
}
// 启动 Cube.js 服务器;如 Cube Store 不可用,降级为普通业务 API 服务,避免整站不可用。
const { app: cubejsApp, cubeMode, cubeError } = await createFullModeApp(cloudConfig);
applyCommonMiddleware(cubejsApp);
// =====================
// 健康检查 (多数据源)
// =====================
cubejsApp.get('/health', async (_req, res) => {
const [systemTest, businessTest, redisTest] = await Promise.all([
withTimeout(database.local.test(), 5000, { success: false, message: '系统数据库检测超时' }),
withTimeout(cloudDb.test(), 5000, { success: false, message: '业务数据库检测超时' }),
withTimeout(redis.test(), 3000, { success: false, message: 'Redis 检测超时' }),
]);
res.json({
status: 'ok',
timestamp: new Date().toISOString(),
build: getBuildIdentity(),
databases: {
system: systemTest,
local: systemTest,
cloud: businessTest,
},
services: {
redis: redisTest,
cube: {
success: cubeMode === 'cube',
mode: cubeMode,
message: cubeMode === 'cube' ? 'Cube.js 服务正常' : `Cube.js 已降级: ${cubeError || '未知错误'}`,
},
},
});
});
// =====================
// 认证 API
// =====================
cubejsApp.get('/api/auth/providers', require('./api/auth').getProviders);
cubejsApp.get('/api/auth/dingtalk/login', require('./api/auth').startDingTalkLogin);
cubejsApp.get('/api/auth/google/login', require('./api/auth').startGoogleLogin);
cubejsApp.post('/api/auth/login', require('./api/auth').login);
cubejsApp.post('/api/auth/local-preview', require('./api/auth').localPreview);
cubejsApp.post('/api/auth/callback', require('./api/auth').callback);
cubejsApp.get('/api/auth/verify', require('./api/auth').verify);
// =====================
// 公开访问的 API(无需认证)
// =====================
cubejsApp.use('/api/install', installRoutes);
cubejsApp.use('/api/sso', thirdPartySsoRoutes);
cubejsApp.use('/api/desktop-client', desktopClientRoutes);
cubejsApp.use('/api/public/taobao-detail-plus', taobaoDetailPlusRoutes);
cubejsApp.use('/api/public/planning-may-product', planningMayProductPublicRoutes);
cubejsApp.use('/api/external/selection-fission/presale', presaleExternalRoutes);
cubejsApp.use('/api/external/selection-fission/delist', delistExternalRoutes);
cubejsApp.use('/api/campaign', campaignCloudRoutes);
cubejsApp.use('/api/external/selection-fission/1688-products', alibaba1688ProductExternalRoutes);
cubejsApp.use('/api/external/selection-fission', planningSelectionFissionExternalRoutes);
cubejsApp.use('/api/external/presale', presaleExternalRoutes);
// 系统配置的 GET 接口公开访问(登录页需要获取网站名称和 Logo)
registerPublicSystemConfigRoute(cubejsApp);
// =====================
// 需要认证的 API
// =====================
cubejsApp.use('/api/admin/sso-clients', authMiddleware, authMiddleware.requireRole('admin'), thirdPartySsoAdminRoutes);
cubejsApp.use('/api/admin', authMiddleware, adminRoutes);
cubejsApp.use('/api/desktop-presence', authMiddleware, desktopPresenceRoutes);
cubejsApp.use('/api/desktop-execution', desktopExecutionTaskRoutes);
cubejsApp.use('/api/product-code-board', authMiddleware, productCodeBoardRoutes);
cubejsApp.use('/api/product-analysis', authMiddleware, productAnalysisRoutes);
cubejsApp.use('/api/marketing-events', authMiddleware, marketingEventsRoutes);
cubejsApp.use('/api/promotion-module', authMiddleware, promotionModuleRoutes);
cubejsApp.use('/api/planning-upload', authMiddleware, planningUploadPageCache, planningUploadRoutes);
cubejsApp.use('/api/channel', authMiddleware, channelPageCache, channelRoutes);
cubejsApp.use('/api/product-monitoring', authMiddleware, productMonitoringRoutes);
cubejsApp.use('/api/modular-stock-monitor', authMiddleware, modularStockMonitorRoutes);
cubejsApp.use('/api/mkh-bom', authMiddleware, mkhBomRoutes);
// 仓储中心发货时效(2026-10-20 新增):列表左侧侧栏,11 个主仓超时未发
cubejsApp.use('/api/warehouse-ship-timeliness', authMiddleware, warehouseShipTimelinessRoutes);
// 仓储中心物流转运异常(2026-10-21 新增):每日 09:00 核验前一日已发货单的物流记录
cubejsApp.use('/api/warehouse-logistics-exception', authMiddleware, warehouseLogisticsExceptionRoutes);
cubejsApp.use('/api/daily-inventory', authMiddleware, dailyInventoryRoutes);
cubejsApp.use('/api/daily-inventory-notification', authMiddleware, dailyInventoryNotificationRoutes);
cubejsApp.use('/api/stock-sales-analysis', authMiddleware, stockSalesAnalysisRoutes);
cubejsApp.use('/api/picking-bin-sales-analysis', authMiddleware, pickingBinSalesAnalysisRoutes);
cubejsApp.use('/api/return-inventory-warning', authMiddleware, returnInventoryWarningRoutes);
// 崔桥工厂仓客退:退货入库核销 + 每日库存监控
cubejsApp.use('/api/return-monitor', authMiddleware, returnMonitorRoutes);
// 崔桥工厂仓客退:退货库存预警(箱及仓位库存 · 崔桥工厂客退临时上架仓)
cubejsApp.use('/api/return-stock-warning', authMiddleware, returnStockWarningRoutes);
// 缺货补货监控(拣货位缺货 → 从存货位补货)
cubejsApp.use('/api/bin-replenish', authMiddleware, binReplenishRoutes);
// =====================
// 数据分析 API(公开访问,可根据需要添加认证)
// =====================
cubejsApp.use('/api/analysis', analysisPageCache, analysisRoutes);
// =====================
// 数据刷新 API(需要认证)
// =====================
cubejsApp.post('/api/admin/refresh', authMiddleware, async (req, res) => {
try {
const { date } = req.body;
console.log(`[API] 手动触发数据刷新: ${date || '昨天'}`);
const result = await manualRefresh(date);
res.json({ success: true, ...result });
} catch (error) {
res.status(500).json({ success: false, error: error.message });
}
});
// =====================
// 重新加载云数据库配置 API
// =====================
cubejsApp.post('/api/admin/database/reload', authMiddleware, async (req, res) => {
try {
console.log('🔄 正在重新加载云数据库配置...');
res.json({
success: true,
message: '配置已保存,需要重启服务才能生效。请执行: pm2 restart maixiang'
});
} catch (error) {
res.status(500).json({ success: false, message: error.message });
}
});
// =====================
// 统一 API 兜底(必须放在所有路由之后)
// =====================
// 背景:此前没有任何 4 参错误处理中间件,路由里抛出的异常会落到 Express
// 默认处理器,返回一张 HTML 的 "Internal Server Error" 页面;前端 axios
// 读不到 error / message 字段,只能显示 "Request failed with status code 500",
// 出问题时完全看不到真实原因。这里统一返回 JSON 并打印堆栈。
cubejsApp.use('/api', (req, res) => {
res.status(404).json({
success: false,
error: `接口不存在: ${req.method} ${req.originalUrl}`,
});
});
cubejsApp.use((err, req, res, next) => {
if (res.headersSent) {
return next(err);
}
const rawStatus = Number(err?.status || err?.statusCode);
const status = Number.isFinite(rawStatus) && rawStatus >= 400 && rawStatus <= 599
? rawStatus
: 500;
const messageText = err?.message || '服务器内部错误';
console.error(`❌ [API ${status}] ${req.method} ${req.originalUrl} -> ${messageText}`);
if (err?.stack) {
console.error(err.stack);
}
return res.status(status).json({ success: false, error: messageText });
});
console.log('='.repeat(50));
console.log('🚀 后端服务已启动');
console.log(`📡 服务地址: http://localhost:${process.env.PORT || 4000}`);
console.log(cubeMode === 'cube'
? `📊 Cube.js API: http://localhost:${process.env.PORT || 4000}/cubejs-api`
: '📊 Cube.js API: 已降级不可用,业务 API 继续运行');
// 测试数据库连接
console.log('\n📦 数据库连接测试:');
const [systemTest, businessTest, redisTest] = await Promise.all([
withTimeout(database.local.test(), 5000, { message: '系统数据库检测超时' }),
withTimeout(cloudDb.test(), 5000, { message: '业务数据库检测超时' }),
withTimeout(redis.test(), 3000, { message: 'Redis 检测超时' }),
]);
console.log(` [系统] ${systemTest.message}`);
console.log(` [业务] ${businessTest.message}`);
console.log(` [缓存] ${redisTest.message}`);
console.log('='.repeat(50));
// 每日进销存截图通知:与「后台定时任务总开关」解耦,保证即使总开关关闭,
// 只要功能启用就仍会按配置时间推送(可用 DAILY_INVENTORY_NOTIFICATION_ENABLED=false 单独关闭)。
// 它每分钟只做一次轻量判断,命中配置时间才真正截图上传。
startDailyInventoryNotificationScheduler();
if (String(process.env.ENABLE_BACKGROUND_JOBS || 'true').toLowerCase() === 'false') {
console.log('⏸️ 后台定时任务和预热已关闭,业务请求按需处理');
return;
}
startScheduler();
startStockSelectionSchedulers();
startTaobaoProductEmbeddingSchedulers();
startPddSkuDimensionSnapshotSchedulers();
startPlanningMayProductSnapshotSchedulers();
startPlanningDingWorkflowSyncSchedulers();
startOpsBIncentiveSnapshotSchedulers();
startGoodsFirstSeenScheduler();
startAlibaba1688ImageSearchExpiryScheduler();
startMkhReplenishAlertScheduler();
// MKH-BOM 页面索引预热:订单两表全表扫很贵(冷查分钟级),必须由后台保持热态,
// 不能让「打开页面 / F5」的用户去等(见 jobs/mkhBomPrewarmJob.js 文件头)
startMkhBomPrewarmScheduler();
startWarehouseLogisticsExceptionNotifyScheduler();
startShipTimelinessNotifyScheduler();
startDailyInventorySnapshotScheduler();
// Keep the first selection-pool page request from paying the remote schema
// inspection round-trip over the planning database tunnel.
setTimeout(() => {
warmSelectionFissionReadSchema()
.then(() => console.log('[SelectionFission] 列表读取结构预热完成'))
.catch((error) => console.warn('[SelectionFission] 列表读取结构预热失败:', error.message));
}, 1000);
if (isStartupPrewarmEnabled()) {
setTimeout(() => {
if (typeof prewarmChannelHotData === 'function') {
runGuardedPrewarm('channel-hot-data', () => prewarmChannelHotData({ skipCoverage: true })).catch((error) => {
console.warn('⚠️ 渠道默认查询预热失败:', error.message);
});
}
}, 8000);
setTimeout(() => {
if (typeof analysisRoutes.prewarmHotAnalysisPages === 'function') {
runGuardedPrewarm('analysis-hot-pages', () => analysisRoutes.prewarmHotAnalysisPages()).catch((error) => {
console.warn('⚠️ 分析页默认查询预热失败:', error.message);
});
}
}, 10000);
if (typeof analysisRoutes.prewarmHotAnalysisPages === 'function') {
const analysisPrewarmTimer = setInterval(() => {
runGuardedPrewarm('analysis-hot-pages:interval', () => analysisRoutes.prewarmHotAnalysisPages()).catch((error) => {
console.warn('⚠️ 分析页默认查询定时预热失败:', error.message);
});
}, 10 * 60 * 1000);
if (typeof analysisPrewarmTimer.unref === 'function') {
analysisPrewarmTimer.unref();
}
}
} else {
console.log('⏸️ 启动预热已关闭,可通过 ENABLE_STARTUP_PREWARM=true 开启');
}
if (!isStartupPrewarmEnabled() && typeof prewarmChannelStockMonitorDashboardDefaultSnapshot === 'function') {
if (typeof prewarmChannelIdDefaultSnapshots === 'function') {
setTimeout(() => {
runGuardedPrewarm(
'channel-id-analysis-resilience',
() => prewarmChannelIdDefaultSnapshots({ skipCoverage: true })
).catch((error) => {
console.warn('⚠️ ID数据分析韧性快照预热失败:', error.message);
});
}, CHANNEL_ID_RESILIENCE_PREWARM_DELAY_MS);
}
if (typeof prewarmChannelIdDashboardDefaultSnapshot === 'function') {
setTimeout(() => {
runGuardedPrewarm(
'channel-id-dashboard-resilience',
() => prewarmChannelIdDashboardDefaultSnapshot({ skipCoverage: true })
).catch((error) => {
console.warn('⚠️ ID数据分析仪表盘韧性快照预热失败:', error.message);
});
}, CHANNEL_ID_RESILIENCE_PREWARM_DELAY_MS + 15000);
}
setTimeout(() => {
runGuardedPrewarm(
'channel-stock-monitor-resilience',
() => prewarmChannelStockMonitorDashboardDefaultSnapshot({ skipCoverage: true })
).catch((error) => {
console.warn('⚠️ 库存销售影响仪表盘韧性快照预热失败:', error.message);
});
}, CHANNEL_STOCK_MONITOR_RESILIENCE_PREWARM_DELAY_MS);
}
if (String(process.env.ENABLE_BRAND_ANALYSIS_PREWARM || 'true').toLowerCase() !== 'false'
&& typeof prewarmBrandAnalysisDefault === 'function') {
setTimeout(() => {
runGuardedPrewarm('brand-analysis-default', () => prewarmBrandAnalysisDefault())
.then((result) => {
console.log(
`[BrandAnalysis] default prewarm completed total=${result.total || 0} elapsedMs=${result.elapsedMs || 0}`
);
})
.catch((error) => {
console.warn('⚠️ 品牌维度默认真实数据预热失败:', error.message);
});
}, BRAND_ANALYSIS_PREWARM_DELAY_MS);
}
const cron = require('node-cron');
if (typeof prewarmChannelHotData === 'function') {
cron.schedule('0 1 * * *', async () => {
console.log('🧊 凌晨 1 点执行渠道 23 小时缓存预热...');
await runGuardedPrewarm(
'channel-hot-data:daily',
() => prewarmChannelHotData({ forceRefresh: true, skipCoverage: true })
);
}, {
timezone: 'Asia/Shanghai',
});
console.log('[Scheduler] 渠道 23 小时缓存预热任务已注册: 每天01:00执行');
}
if (process.env.NODE_ENV === 'production') {
const alertChecker = require('./services/alertChecker');
cron.schedule('*/5 * * * *', async () => {
console.log('🔔 执行预警检查...');
await alertChecker.checkAllRules();
});
}
}
async function bootstrap() {
const installStatus = await getInstallStatus();
if (installStatus.required) {
await startInstallServer(installStatus);
return;
}
if (installStatus.databaseUnavailable) {
console.warn(`⚠️ 系统数据库暂时不可用,不进入降级拦截模式: ${installStatus.systemDatabase?.reason || 'unknown'}`);
await startServer({ skipLocalSchema: true });
return;
}
await startServer();
}
bootstrap().catch((error) => {
console.error('❌ 服务启动失败:', error);
process.exit(1);
});
async function shutdownGracefully() {
await Promise.allSettled([
cloudDb.close(),
jianSunDb.close(),
database.close(),
redis.close(),
]);
}
// 优雅关闭
process.on('SIGTERM', async () => {
console.log('正在关闭服务...');
await shutdownGracefully();
process.exit(0);
});
process.on('SIGINT', async () => {
console.log('正在关闭服务...');
await shutdownGracefully();
process.exit(0);
});