From 52181c44bd2760ba360fa6503d9b0150bc276470 Mon Sep 17 00:00:00 2001 From: liufumingren Date: Thu, 24 Sep 2026 03:26:15 +0800 Subject: [PATCH] =?UTF-8?q?feat(frontConfig):=20=E5=89=8D=E7=AB=AF?= =?UTF-8?q?=E7=8B=AC=E7=AB=8B=E9=83=A8=E7=BD=B2=E5=9F=9F=E5=90=8D=E9=AA=8C?= =?UTF-8?q?=E8=AF=81=EF=BC=88DNS=20TXT=20=E6=A0=A1=E9=AA=8C=20+=20?= =?UTF-8?q?=E9=AA=8C=E8=AF=81=E9=97=B8=E9=97=A8=EF=BC=89=EF=BC=8CfrontConf?= =?UTF-8?q?ig=20=E6=8E=A5=E5=8F=A3=E4=BB=8E=20setting.warehouse=20?= =?UTF-8?q?=E8=BF=81=E7=A7=BB=E8=87=B3=E7=8B=AC=E7=AB=8B=20service?= =?UTF-8?q?=EF=BC=88getInfo/getCert/saveInfo/saveCert/setDomain/getDomain/?= =?UTF-8?q?checkDomain=EF=BC=89?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- app/model/warehouse_front_config.js | 44 + app/schedule/domain_verify_scan.js | 183 ++ app/service/systemMethods/frontConfig.js | 236 ++- .../systemMethods/setting/warehouse.js | 107 +- app/service/systems/frontConfig.js | 1626 +++++++++++++++++ config/config.default.js | 11 + ...in-verify-to-wms-warehouse-front-config.js | 186 ++ script/deploy-cert-sync.cjs | 11 + script/warehouse-cert-sync.cjs | 42 +- 9 files changed, 2329 insertions(+), 117 deletions(-) create mode 100644 app/schedule/domain_verify_scan.js create mode 100644 app/service/systems/frontConfig.js create mode 100644 database/migrations/20260924120000-add-domain-verify-to-wms-warehouse-front-config.js diff --git a/app/model/warehouse_front_config.js b/app/model/warehouse_front_config.js index 0575871..91ebc21 100644 --- a/app/model/warehouse_front_config.js +++ b/app/model/warehouse_front_config.js @@ -9,6 +9,8 @@ * 管理后台保存后置为待同步,由定时任务同步到 nginx 后回写状态。 * - 证书启用/停用由整行删除或 sync_status 表达;证书到期由 cert_expire_at * 判断,不单独保留证书 status 列。 + * - domain_status 状态机:0-未验证,1-已验证(DNS TXT 校验通过),2-验证失败; + * 未验证/验证失败的域名禁止上传证书与对外公共拉取,管理后台设置域名后回落到 0。 * - domain 唯一索引(uk_domain)为 MySQL 可空列唯一索引:允许多个 NULL, * 应用层在写入非空 domain 前必须做唯一性校验,不能依赖数据库约束报错。 * - store_id 唯一索引(uk_store_id):每仓一行,由数据库层保证。 @@ -43,6 +45,44 @@ module.exports = app => { allowNull: true, comment: '仓库自持域名;可空列唯一索引允许多个 NULL,非空值唯一性需应用层校验', }, + domain_status: { + type: TINYINT, + allowNull: false, + defaultValue: 0, + validate: { + isIn: { + args: [[ 0, 1, 2 ]], + msg: '域名验证状态不合法:0-未验证,1-已验证,2-验证失败', + }, + }, + comment: '域名验证状态:0-未验证,1-已验证,2-验证失败', + }, + domain_verify_host: { + type: STRING(255), + allowNull: true, + comment: '待校验 TXT 记录主机名(wmsv-<随机码>.<域名>)', + }, + domain_verify_token: { + type: STRING(64), + allowNull: true, + comment: '待校验 TXT 记录值(32 位 hex)', + }, + domain_verified_at: { + type: DATE, + allowNull: true, + comment: '域名验证通过时间', + }, + domain_verify_attempts: { + type: INTEGER(11), + allowNull: false, + defaultValue: 0, + comment: '域名验证尝试次数', + }, + domain_last_error: { + type: STRING(500), + allowNull: true, + comment: '最近一次域名验证失败原因', + }, title: { type: STRING(100), allowNull: true, @@ -158,6 +198,10 @@ module.exports = app => { name: 'idx_sync_status', fields: [ 'sync_status' ], }, + { + name: 'idx_domain_status', + fields: [ 'domain_status' ], + }, ], }); diff --git a/app/schedule/domain_verify_scan.js b/app/schedule/domain_verify_scan.js new file mode 100644 index 0000000..93b6064 --- /dev/null +++ b/app/schedule/domain_verify_scan.js @@ -0,0 +1,183 @@ +// app/schedule/domain_verify_scan.js +'use strict'; + +/** + * 域名验证扫描定时任务。 + * + * 按 config.frontConfig.domainVerify.interval 周期性触发(默认 10m), + * 扫描 wms_warehouse_front_config 中「已生成待校验 TXT 记录、且尚未通过验证」的行, + * 逐行解析 DNS TXT 记录并回写 domain_status / domain_verified_at / + * domain_verify_attempts / domain_last_error;只有通过验证的域名才会被公共拉取接口 + * 与 nginx server 块生成流程放行。 + * + * 并发控制(双保险): + * 1. 进程内重入标志 ctx.app._domainVerifyScanRunning:上一轮未结束时跳过本轮; + * 2. Redis 跨进程互斥锁 SET NX EX:多实例部署时同一轮只有一个实例执行, + * TTL 取 config.frontConfig.domainVerify.lockTtlSeconds(默认 600s); + * Redis 不可用或抛错时降级为「仅进程内防重入」并 WARN, + * 不因缓存故障中断域名验证。 + * + * 业务逻辑全部委托 service.systems.frontConfig.verifyPendingDomains(本文件不写 SQL); + * 任务失败只记录错误日志,不向上抛出,避免 schedule 崩溃。 + * + * 关闭方式:config.frontConfig.domainVerify.enable = false,此时 schedule + * 标记为 disable,Egg 不注册本任务(进程内不会执行)。 + */ + +/** @type {string} 跨进程互斥锁 key */ +const LOCK_CACHE_KEY = 'schedule:domain_verify_scan:lock'; +/** @type {string} 日志前缀 tag */ +const LOG_TAG = '[domain_verify_scan]'; +/** @type {number} 锁 TTL 兜底值(秒) */ +const DEFAULT_LOCK_TTL_SECONDS = 600; +/** @type {string} 扫描间隔兜底值 */ +const DEFAULT_INTERVAL = '10m'; + +/** + * 获取 Redis cache 客户端。 + * + * @param {Object} app Egg 应用实例。 + * @return {Object|null} Redis 客户端或 null。 + */ +function getCacheRedisClient(app) { + if (!app || !app.redis || typeof app.redis.get !== 'function') { + return null; + } + + try { + return app.redis.get('cache') || null; + } catch (error) { + return null; + } +} + +/** + * 获取跨进程互斥锁(SET NX EX)。 + * + * @param {Object} ctx Egg 上下文。 + * @param {number} ttlSeconds 锁 TTL(秒)。 + * @param {string} lockValue 锁持有者标识(pid + 时间戳)。 + * @return {Promise} 是否获取成功;Redis 不可用时返回 true(退化为进程内防重入)。 + */ +async function acquireLock(ctx, ttlSeconds, lockValue) { + const redis = getCacheRedisClient(ctx.app); + + if (!redis || typeof redis.set !== 'function') { + ctx.logger.warn(`${LOG_TAG} Redis 不可用,跨进程互斥降级为进程内防重入`); + return true; + } + + try { + const result = await redis.set(LOCK_CACHE_KEY, lockValue, 'EX', ttlSeconds, 'NX'); + return result === 'OK'; + } catch (error) { + ctx.logger.warn(`${LOG_TAG} 获取互斥锁失败(按未加锁继续): ${error.message}`); + return true; + } +} + +/** + * 释放跨进程互斥锁(GET 比对 value 后再 DEL,避免误删他人锁)。 + * + * 仍存在极小竞态窗口:本进程 GET 到自己的 value 后、DEL 之前锁恰好 TTL 到期 + * 并被其它实例抢到(value 为 pid + 时间戳,重复概率极低),最坏结果是提前释放 + * 一次锁,不会造成数据错误(service 层 update 自带 id + domain 防并发守卫), + * 因此接受该窗口而不引入 Lua 脚本。 + * + * @param {Object} ctx Egg 上下文。 + * @param {string} lockValue 锁持有者标识(与获取时一致)。 + * @return {Promise} 无返回值。 + */ +async function releaseLock(ctx, lockValue) { + const redis = getCacheRedisClient(ctx.app); + + if (!redis || typeof redis.get !== 'function' || typeof redis.del !== 'function') { + // Redis 不可用则跳过释放,等待 TTL 自然过期 + return; + } + + try { + const current = await redis.get(LOCK_CACHE_KEY); + if (current !== lockValue) { + return; + } + await redis.del(LOCK_CACHE_KEY); + } catch (error) { + ctx.logger.warn(`${LOG_TAG} 释放互斥锁失败(等待 TTL 过期): ${error.message}`); + } +} + +/** + * 域名验证扫描定时任务。 + * + * @param {Object} app Egg 应用实例。 + * @return {Object} 定时任务定义(含 schedule 与 task)。 + */ +module.exports = app => { + // 工厂内动态读取配置:interval / lockTtlSeconds / enable 变更后无需改代码 + const frontConfig = (app.config && app.config.frontConfig) || {}; + const domainVerify = frontConfig.domainVerify || {}; + const interval = typeof domainVerify.interval === 'string' && domainVerify.interval + ? domainVerify.interval + : DEFAULT_INTERVAL; + const lockTtlSeconds = Number(domainVerify.lockTtlSeconds) > 0 + ? Math.floor(Number(domainVerify.lockTtlSeconds)) + : DEFAULT_LOCK_TTL_SECONDS; + + return { + schedule: { + // 固定间隔触发;domainVerify.enable === false 时 disable 为 true, + // Egg 直接不注册本任务(不会进入 task,也不会占用 worker 周期) + interval, + type: 'worker', + immediate: false, + disable: domainVerify.enable === false, + }, + + /** + * 执行一轮域名验证扫描。 + * + * @param {Object} ctx Egg 上下文。 + * @return {Promise} 无返回值。 + */ + async task(ctx) { + // 进程内防重入:单实例上一轮未结束时不再叠加下一轮 + if (ctx.app._domainVerifyScanRunning) { + ctx.logger.info(`${LOG_TAG} 本轮任务跳过,上一轮尚未结束`); + return; + } + + const lockValue = `${process.pid}-${Date.now()}`; + const locked = await acquireLock(ctx, lockTtlSeconds, lockValue); + if (!locked) { + ctx.logger.info(`${LOG_TAG} 未获取到跨进程互斥锁,本轮跳过(其它实例正在执行)`); + return; + } + + ctx.app._domainVerifyScanRunning = true; + const startedAt = Date.now(); + + try { + // 业务逻辑一律委托 service,schedule 内不写 SQL + const summary = await ctx.service.systems.frontConfig.verifyPendingDomains({}); + + ctx.logger.info( + `${LOG_TAG} 本轮完成 scanned=${summary.scanned} verified=${summary.verified}` + + ` failed=${summary.failed} skipped=${summary.skipped}` + + ` errors=${summary.errors.length} duration=${Date.now() - startedAt}ms` + ); + + if (summary.errors.length > 0) { + ctx.logger.warn(`${LOG_TAG} 本轮错误摘要: ${summary.errors.slice(0, 5).join(' | ')}`); + } + } catch (error) { + // service 层已 fail-soft(迁移未执行时返回零统计),此处为最后兜底: + // 只记日志不上抛,避免 schedule 崩溃 + ctx.logger.error(`${LOG_TAG} 本轮执行异常: ${error && error.message ? error.message : String(error)}`); + } finally { + ctx.app._domainVerifyScanRunning = false; + await releaseLock(ctx, lockValue); + } + }, + }; +}; diff --git a/app/service/systemMethods/frontConfig.js b/app/service/systemMethods/frontConfig.js index e6f48de..400a956 100644 --- a/app/service/systemMethods/frontConfig.js +++ b/app/service/systemMethods/frontConfig.js @@ -2,22 +2,39 @@ const MainService = require('../main'); +/** + * 系统方法层:frontConfig(前端独立部署配置接口包装层)。 + * + * 业务实现全部委托 ctx.service.systems.frontConfig:本层只做参数白名单过滤、 + * 鉴权出口与统一成功/失败包装。 + */ class FrontConfigMethodsService extends MainService { constructor(ctx) { super(ctx); - // 公共按域名拉取前端配置:免登录、免权限、免鉴权(保留系统日志,与 workbench 公共接口口径一致) + // 公共按域名拉取:免登录、免权限、免鉴权(保留系统日志,与 workbench 公共接口口径一致) + // 注意:getByDomain 是唯一免登录接口;域名验证接口(setDomain/getDomain/checkDomain)一律需登录 const _noNeedLogin = 'getByDomain'; - const _noNeedRight = 'getByDomain'; - const _noNeedLog = ''; - const _noNeedAuth = 'getByDomain'; + // settings 页配置接口:需登录、免权限、免鉴权(权限由业务层 isWarehouse 判定),不记系统日志 + const _noNeedRight = 'getByDomain,getInfo,getCert,saveInfo,saveCert,setDomain,getDomain,checkDomain'; + const _noNeedLog = 'getInfo,getCert,saveInfo,saveCert,setDomain,getDomain,checkDomain'; + const _noNeedAuth = 'getByDomain,getInfo,getCert,saveInfo,saveCert,setDomain,getDomain,checkDomain'; this.systemInit(_noNeedLogin, _noNeedRight, _noNeedLog, _noNeedAuth); } + /** + * 获取前端独立部署业务服务(systems/frontConfig)。 + * + * @return {Object|null} 业务服务实例;不可用时返回 null。 + */ + getFrontConfigService() { + return (this.service && this.service.systems && this.service.systems.frontConfig) || null; + } + /** * 按域名拉取仓库前端公开配置(公共无鉴权接口)。 * * 安全红线:响应仅含公开字段(domain/title/logo_url/login_bg_url/favicon_url/theme), - * 不含 cert_path、key_path、sync_status、sync_attempts、last_sync_error 等内部字段。 + * 不含 cert_pem/key_pem/cert_path/key_path/sync_status/sync_attempts/last_sync_error 等内部字段。 * * @param {Object} [data={}] 请求参数。 * @param {string} data.domain 待查询域名(必填,非空)。 @@ -27,13 +44,13 @@ class FrontConfigMethodsService extends MainService { async getByDomain(data = {}) { const { domain } = data || {}; - const targetService = this.service && this.service.systems && this.service.systems.setting && this.service.systems.setting.warehouse; - if (!targetService || typeof targetService.getFrontConfigByDomain !== 'function') { + const targetService = this.getFrontConfigService(); + if (!targetService || typeof targetService.getByDomain !== 'function') { return this.fail('获取前端配置失败', { code: 500 }); } try { - const result = await targetService.getFrontConfigByDomain(domain); + const result = await targetService.getByDomain(domain); return this.success('获取成功', { ...result, code: 200 }); } catch (error) { return this.fail(error.message || '获取前端配置失败', { @@ -41,6 +58,209 @@ class FrontConfigMethodsService extends MainService { }); } } + + /** + * 查询当前仓库前端独立部署品牌配置(settings 页回显,需登录)。 + * + * 仅返回品牌与基础字段(warehouse_id/domain/title/logo_url/favicon_url/login_bg_url/theme/updated_at), + * 不含证书/私钥原文与同步状态等内部字段(证书回显走 frontConfig.getCert)。 + * + * @return {Promise} 统一响应结果。 + */ + async getInfo() { + const targetService = this.getFrontConfigService(); + if (!targetService || typeof targetService.getInfo !== 'function') { + return this.fail('获取前端配置失败', { code: 500 }); + } + + try { + const result = await targetService.getInfo(); + return this.success('ok', result); + } catch (error) { + return this.fail(error.message || '获取前端配置失败', { + code: Number(error.code) || 500, + }); + } + } + + /** + * 查询当前仓库前端独立部署证书配置(settings 页回显,需登录)。 + * + * 响应含证书原文(cert_pem)与私钥原文(key_pem,取自 cert_key 列), + * 仅供仓库主体登录后的 settings 页回显,公共无鉴权接口 frontConfig.getByDomain + * 仍只返回公开字段白名单。 + * + * @return {Promise} 统一响应结果。 + */ + async getCert() { + const targetService = this.getFrontConfigService(); + if (!targetService || typeof targetService.getCert !== 'function') { + return this.fail('获取前端证书配置失败', { code: 500 }); + } + + try { + const result = await targetService.getCert(); + return this.success('ok', result); + } catch (error) { + return this.fail(error.message || '获取前端证书配置失败', { + code: Number(error.code) || 500, + }); + } + } + + /** + * 保存当前仓库前端独立部署品牌配置(upsert,一仓一行,仅品牌字段部分更新,需登录)。 + * + * domain 与证书字段不再受理:domain 变更必须走 frontConfig.setDomain(域名验证通过后方可上传证书); + * cert_pem/key_pem/cert_path/key_path/cert_expire_at 一律被白名单过滤忽略。 + * + * @param {Object} data 请求参数。 + * @param {string} [data.title] 站点标题(≤100 字符,空值清空)。 + * @param {string} [data.logo_url] Logo 地址(≤255 字符,空值清空)。 + * @param {string} [data.favicon_url] 站点 favicon 图标地址(≤255 字符,空值清空)。 + * @param {string} [data.login_bg_url] 登录页背景图地址(≤255 字符,空值清空)。 + * @param {Object|string} [data.theme] 主题配置(合法 JSON 对象或 JSON 字符串,空值清空)。 + * @return {Promise} 统一响应结果。 + */ + async saveInfo(data = {}) { + const targetService = this.getFrontConfigService(); + if (!targetService || typeof targetService.saveInfo !== 'function') { + return this.fail('保存前端配置失败', { code: 500 }); + } + + try { + const source = data || {}; + const params = {}; + + // domain/cert_path/key_path/cert_pem/key_pem/cert_expire_at 均不受理: + // domain 变更走 setDomain,证书与有效期字段由后端权威维护,前端传值直接忽略 + for (const key of [ 'title', 'logo_url', 'favicon_url', 'login_bg_url', 'theme' ]) { + if (Object.prototype.hasOwnProperty.call(source, key)) { + params[key] = source[key]; + } + } + + const result = await targetService.saveInfo(params); + return this.success('ok', result); + } catch (error) { + return this.fail(error.message || '保存前端配置失败', { + code: Number(error.code) || 500, + }); + } + } + + /** + * 上传当前仓库前端独立部署证书(需登录、仅仓库主体)。 + * + * domain 不再受理:域名一律取库内已设置且验证通过的值(前端若仍传 data.domain 一律忽略), + * 未设置域名或域名未通过 TXT 验证时由业务层返回 400。 + * 后端自动写入 cert_expire_at(证书 validTo 权威值),证书/私钥内容直接入库(不落盘), + * 保存后清理该域名的公共拉取缓存并返回证书配置输出 + * (响应含证书/私钥原文回显,13 字段,口径与 frontConfig.getCert 一致)。 + * + * @param {Object} data 请求参数。 + * @param {string} data.pem 证书 PEM 文本(必填)。 + * @param {string} data.key 私钥 PEM 文本(必填,与证书成对)。 + * @return {Promise} 统一响应结果。 + */ + async saveCert(data = {}) { + const targetService = this.getFrontConfigService(); + if (!targetService || typeof targetService.saveCert !== 'function') { + return this.fail('上传前端证书失败', { code: 500 }); + } + + try { + const source = data || {}; + const { pem, key } = source; + + // data.domain 不再受理:域名只认库内已设置并验证通过的值,前端若仍传 domain 一律忽略 + const result = await targetService.saveCert({ + pem, + key, + }); + return this.success('ok', result); + } catch (error) { + return this.fail(error.message || '上传前端证书失败', { + code: Number(error.code) || 500, + }); + } + } + + /** + * 设置当前仓库前端独立部署域名(需登录、仅仓库主体)。 + * + * 设置成功会下发一次性 DNS TXT 校验记录(verify_host/verify_value)与 CNAME 目标(cname); + * 域名发生变更时会同时清空既有证书并重置同步状态(旧证书不覆盖新域名)。 + * + * @param {Object} data 请求参数。 + * @param {string} data.domain 仓库自持域名(必填,非空,≤100 字符,全局唯一)。 + * @return {Promise} 统一响应结果(code=1);data 含 + * warehouse_id/domain/domain_status/verify_host/verify_value/cname/verified_at/attempts/last_error。 + */ + async setDomain(data = {}) { + const targetService = this.getFrontConfigService(); + if (!targetService || typeof targetService.setDomain !== 'function') { + return this.fail('设置域名失败', { code: 500 }); + } + + try { + const result = await targetService.setDomain(data || {}); + return this.success('ok', result); + } catch (error) { + return this.fail(error.message || '设置域名失败', { + code: Number(error.code) || 500, + }); + } + } + + /** + * 查询当前仓库前端独立部署域名与验证状态(需登录、仅仓库主体)。 + * + * 返回待校验的 verify_host/verify_value 与 cname;domain_status=1(已验证)时 + * verify_host/verify_value 返回空串(校验令牌已无用途);无记录时返回空值默认。 + * + * @return {Promise} 统一响应结果(code=1);data 含 + * warehouse_id/domain/domain_status/verify_host/verify_value/cname/verified_at/attempts/last_error。 + */ + async getDomain() { + const targetService = this.getFrontConfigService(); + if (!targetService || typeof targetService.getDomain !== 'function') { + return this.fail('获取域名配置失败', { code: 500 }); + } + + try { + const result = await targetService.getDomain(); + return this.success('ok', result); + } catch (error) { + return this.fail(error.message || '获取域名配置失败', { + code: Number(error.code) || 500, + }); + } + } + + /** + * 主动校验当前仓库前端独立部署域名的 DNS TXT 记录(需登录、仅仓库主体)。 + * + * 校验结果会回写 domain_status/domain_verified_at/attempts/last_error; + * 响应额外含 verified(本次是否通过)与 resolved_values(本次解析到的 TXT 值,最多 5 条)。 + * + * @return {Promise} 统一响应结果(code=1);未设置域名时 code=400。 + */ + async checkDomain() { + const targetService = this.getFrontConfigService(); + if (!targetService || typeof targetService.checkDomain !== 'function') { + return this.fail('校验域名失败', { code: 500 }); + } + + try { + const result = await targetService.checkDomain(); + return this.success('ok', result); + } catch (error) { + return this.fail(error.message || '校验域名失败', { + code: Number(error.code) || 500, + }); + } + } } module.exports = FrontConfigMethodsService; diff --git a/app/service/systemMethods/setting/warehouse.js b/app/service/systemMethods/setting/warehouse.js index cc30231..806a169 100644 --- a/app/service/systemMethods/setting/warehouse.js +++ b/app/service/systemMethods/setting/warehouse.js @@ -6,9 +6,9 @@ class SettingWarehouseMethodsService extends MainService { constructor(ctx) { super(ctx); const _noNeedLogin = ''; - const _noNeedRight = 'getSettings,getFieldMeta,saveSettings,getFrontConfig,saveFrontConfig,saveFrontCert,getweChatApp'; + const _noNeedRight = 'getSettings,getFieldMeta,saveSettings,getweChatApp'; const _noNeedLog = '*'; - const _noNeedAuth = 'getSettings,getFieldMeta,saveSettings,getFrontConfig,saveFrontConfig,saveFrontCert,getweChatApp'; + const _noNeedAuth = 'getSettings,getFieldMeta,saveSettings,getweChatApp'; this.systemInit(_noNeedLogin, _noNeedRight, _noNeedLog, _noNeedAuth); } @@ -80,109 +80,6 @@ class SettingWarehouseMethodsService extends MainService { } } - /** - * 查询当前仓库前端独立部署配置(settings 页回显)。 - * - * 响应含证书原文(cert_pem)与私钥原文(key_pem)回显, - * 仅限登录用户查询其仓库上下文绑定的配置,供仓库主体 settings 页回显; - * 公共无鉴权接口 frontConfig.getByDomain 不经过本出口,仍只返回公开字段白名单。 - * - * @return {Promise} 统一响应结果。 - */ - async getFrontConfig() { - const targetService = this.service && this.service.systems && this.service.systems.setting && this.service.systems.setting.warehouse; - - if (!targetService || typeof targetService.getFrontConfig !== 'function') { - return this.fail('获取仓库前端配置失败', { code: 500 }); - } - - try { - const result = await targetService.getFrontConfig(); - return this.success('ok', result); - } catch (error) { - return this.fail(error.message || '获取仓库前端配置失败', { - code: Number(error.code) || 500, - }); - } - } - - /** - * 保存当前仓库前端独立部署品牌配置(upsert,一仓一行,仅品牌字段部分更新)。 - * - * domain 与证书字段不再受理:domain 变更必须走 saveFrontCert 重新校验证书; - * cert_pem/key_pem/cert_path/key_path/cert_expire_at 一律被白名单过滤忽略。 - * - * @param {Object} data 请求参数。 - * @param {string} [data.title] 站点标题(≤100 字符,空值清空)。 - * @param {string} [data.logo_url] Logo 地址(≤255 字符,空值清空)。 - * @param {string} [data.favicon_url] 站点 favicon 图标地址(≤255 字符,空值清空)。 - * @param {string} [data.login_bg_url] 登录页背景图地址(≤255 字符,空值清空)。 - * @param {Object|string} [data.theme] 主题配置(合法 JSON 对象或 JSON 字符串,空值清空)。 - * @return {Promise} 统一响应结果。 - */ - async saveFrontConfig(data = {}) { - const targetService = this.service && this.service.systems && this.service.systems.setting && this.service.systems.setting.warehouse; - - if (!targetService || typeof targetService.saveFrontConfig !== 'function') { - return this.fail('保存仓库前端配置失败', { code: 500 }); - } - - try { - const source = data || {}; - const params = {}; - - // domain/cert_path/key_path/cert_pem/key_pem/cert_expire_at 均不受理: - // domain 变更走 saveFrontCert,证书与有效期字段由后端权威维护,前端传值直接忽略 - for (const key of [ 'title', 'logo_url', 'favicon_url', 'login_bg_url', 'theme' ]) { - if (Object.prototype.hasOwnProperty.call(source, key)) { - params[key] = source[key]; - } - } - - const result = await targetService.saveFrontConfig(params); - return this.success('ok', result); - } catch (error) { - return this.fail(error.message || '保存仓库前端配置失败', { - code: Number(error.code) || 500, - }); - } - } - - /** - * 上传当前仓库前端独立部署证书(domain + 证书/私钥成对,需登录、仅仓库主体)。 - * - * 后端自动写入 cert_expire_at(证书 validTo 权威值),证书/私钥内容直接入库(不落盘), - * 保存后清理新旧 domain 的公共拉取缓存并返回完整配置输出 - * (响应含证书/私钥原文回显,口径与 getFrontConfig 一致)。 - * - * @param {Object} data 请求参数。 - * @param {string} data.domain 仓库自持域名(必填,非空,≤100 字符,全局唯一)。 - * @param {string} data.pem 证书 PEM 文本(必填)。 - * @param {string} data.key 私钥 PEM 文本(必填,与证书成对)。 - * @return {Promise} 统一响应结果。 - */ - async saveFrontCert(data = {}) { - const targetService = this.service && this.service.systems && this.service.systems.setting && this.service.systems.setting.warehouse; - - if (!targetService || typeof targetService.saveFrontCert !== 'function') { - return this.fail('上传前端证书失败', { code: 500 }); - } - - try { - const source = data || {}; - const { domain, pem, key } = source; - const result = await targetService.saveFrontCert({ - domain, - pem, - key, - }); - return this.success('ok', result); - } catch (error) { - return this.fail(error.message || '上传前端证书失败', { - code: Number(error.code) || 500, - }); - } - } /** * 获取当前仓库启用的微信小程序授权配置(wms_wechat_app)。 diff --git a/app/service/systems/frontConfig.js b/app/service/systems/frontConfig.js new file mode 100644 index 0000000..07296fd --- /dev/null +++ b/app/service/systems/frontConfig.js @@ -0,0 +1,1626 @@ +'use strict'; + +const crypto = require('node:crypto'); +// 域名验证 TXT 记录的兜底解析使用 Node 内置 DNS(本文件为全仓首次引入 node:dns): +// DoH(ctx.curl)不可用时降级为系统解析;仅服务域名验证链路,不参与业务主链路。 +const dns = require('node:dns'); + +const { Service } = require('egg'); + +// 仓库前端配置品牌文本字段元信息(对应 wms_warehouse_front_config,一仓一行)。 +// 域名与证书字段不在此列:domain 只能通过 frontConfig.setDomain 设置(并先通过域名验证), +// cert_pem/cert_key/cert_path/key_path 只能通过证书上传接口(saveCert)变更。 +const TEXT_FIELDS = Object.freeze([ + Object.freeze({ key: 'title', name: 'title', maxLength: 100 }), + Object.freeze({ key: 'logo_url', name: 'logo_url', maxLength: 255 }), + Object.freeze({ key: 'favicon_url', name: 'favicon_url', maxLength: 255 }), + Object.freeze({ key: 'login_bg_url', name: 'login_bg_url', maxLength: 255 }), +]); + +// 公共按域名拉取接口对外输出的字段白名单(安全红线:严禁输出证书/私钥内容与证书路径、同步状态等内部字段) +const PUBLIC_FIELDS = Object.freeze([ + 'domain', + 'title', + 'logo_url', + 'login_bg_url', + 'favicon_url', + 'theme', +]); + +// 公共按域名拉取接口缓存 TTL(秒) +const PUBLIC_CACHE_TTL_SECONDS = 600; +// 未登记域名空缓存 TTL(秒):短缓存兜底防穿透,域名登记后由保存流程主动失效 +const PUBLIC_MISS_CACHE_TTL_SECONDS = 60; + +// 证书/私钥 PEM 文本最大长度(正常 RSA/ECC 证书远小于该值,防止异常大报文) +const PEM_MAX_LENGTH = 64 * 1024; + +// 域名验证状态(与 wms_warehouse_front_config.domain_status 列及模型 validate 保持一致) +const DOMAIN_STATUS_UNVERIFIED = 0; +const DOMAIN_STATUS_VERIFIED = 1; +const DOMAIN_STATUS_FAILED = 2; + +// 域名形态:至少两段标签,每段 1~63 位、仅字母数字与连字符、首尾不得为连字符; +// 天然排除通配符 *、下划线、首尾点与单段主机名(长度上限由 normalizeText 的 ≤100 兜住) +const DOMAIN_PATTERN = /^(?!-)[A-Za-z0-9-]{1,63}(?} 无返回值。 + */ + async deleteCacheByKey(cacheKey) { + if (!cacheKey) { + return; + } + + if (this.app && typeof this.app.delCacheAsync === 'function') { + await this.app.delCacheAsync(cacheKey); + return; + } + + if (this.app && typeof this.app.setCacheAsync === 'function') { + await this.app.setCacheAsync(cacheKey, null, 0); + } + } + + /** + * 校验并规范化仓库前端配置的字符串字段。 + * + * @param {*} value 原始值。 + * @param {string} fieldName 字段名。 + * @param {number} maxLength 字段最大长度。 + * @return {string|null} 规范化后的字符串;空值返回 null(表示清空)。 + * @throws {Error} 超长时抛出,状态码 400。 + */ + normalizeText(value, fieldName, maxLength) { + if (value === undefined || value === null) { + return null; + } + + const normalized = String(value).trim(); + if (!normalized) { + return null; + } + + if (normalized.length > maxLength) { + throw this.createError(`${fieldName} 长度不能超过 ${maxLength} 字符`, 400); + } + + return normalized; + } + + /** + * 校验并规范化仓库前端配置的 theme 字段。 + * + * @param {*} value 原始值(对象或 JSON 字符串)。 + * @return {Object|null} 规范化后的主题对象;空值返回 null(表示清空)。 + * @throws {Error} 非合法 JSON 对象时抛出,状态码 400。 + */ + normalizeTheme(value) { + if (value === undefined || value === null || value === '') { + return null; + } + + let parsed = value; + if (typeof value === 'string') { + try { + parsed = JSON.parse(value.trim()); + } catch (error) { + throw this.createError('theme 必须是合法的 JSON 对象', 400); + } + } + + if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) { + throw this.createError('theme 必须是合法的 JSON 对象', 400); + } + + return parsed; + } + + /** + * 校验非空 domain 的全局唯一性(可空列唯一索引允许多 NULL,数据库不兜底)。 + * + * @param {string} domain 待校验域名(非空)。 + * @param {number} excludeWarehouseId 排除的仓库 ID(当前仓库自身)。 + * @return {Promise} 无返回值。 + * @throws {Error} domain 已被其他仓库使用时抛出,状态码 409。 + */ + async assertDomainUnique(domain, excludeWarehouseId) { + const configModel = this.ctx.model && this.ctx.model.WarehouseFrontConfig; + if (!configModel || typeof configModel.findOne !== 'function') { + throw this.createError('WarehouseFrontConfig model 不可用', 500); + } + + const { Op } = this.app.Sequelize; + const existing = await configModel.findOne({ + where: { + domain, + store_id: { [Op.ne]: excludeWarehouseId }, + }, + attributes: [ 'store_id', 'domain' ], + }); + + if (existing) { + throw this.createError(`域名 ${domain} 已被其他仓库使用`, 409); + } + } + + /** + * 从记录(Sequelize 实例或普通对象)读取字段值。 + * + * @param {Object} record 记录实例或普通对象。 + * @param {string} key 字段名。 + * @return {*} 字段值;不可读时返回 null。 + */ + getRecordField(record, key) { + if (!record) { + return null; + } + + if (typeof record.get === 'function') { + return record.get(key); + } + + return Object.prototype.hasOwnProperty.call(record, key) ? record[key] : null; + } + + /** + * 脱敏并截断错误文本:去掉 PEM 块内容、压缩空白、按列宽截断。 + * + * 安全红线:域名验证失败原因会写入 domain_last_error 并回显前端, + * 严禁把原始网络错误/堆栈原样落库(脱敏思路参考 script/warehouse-cert-sync.cjs 的 sanitizeErrorText)。 + * + * @param {*} text 原始错误文本。 + * @return {string} 脱敏截断后的文本(≤500 字符)。 + */ + sanitizeErrorText(text) { + return String(text === undefined || text === null ? '' : text) + .replace(/-----BEGIN [^-]*-----[\s\S]*?-----END [^-]*-----/g, '[PEM 内容已省略]') + .replace(/\s+/g, ' ') + .trim() + .slice(0, DOMAIN_LAST_ERROR_MAX_LENGTH); + } + + /** + * 读取域名验证配置(config.frontConfig.domainVerify),缺失或非法项回退默认值。 + * + * 公共方法:app/schedule 下的域名验证定时任务会直接调用,签名与返回值需保持稳定。 + * + * @return {Object} 域名验证配置,字段如下: + * - enable {boolean}:是否启用域名验证定时任务; + * - interval {string}:扫描间隔(Egg schedule 语法); + * - lockTtlSeconds {number}:Redis 跨进程锁 TTL(秒); + * - batchSize {number}:单轮最多处理行数; + * - dohUrl {string}:DNS-over-HTTPS 服务地址; + * - timeoutMs {number}:单次 DoH 请求超时(毫秒); + * - maxAttempts {number}:自动重试次数上限。 + */ + getDomainVerifyConfig() { + const frontConfig = (this.app && this.app.config && this.app.config.frontConfig) || {}; + const raw = frontConfig.domainVerify || {}; + const toPositiveNumber = (value, fallback) => { + const parsed = Number(value); + return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback; + }; + + return { + enable: raw.enable !== false, + interval: String(raw.interval || '10m'), + lockTtlSeconds: toPositiveNumber(raw.lockTtlSeconds, 600), + batchSize: Math.floor(toPositiveNumber(raw.batchSize, 50)), + dohUrl: String(raw.dohUrl || 'https://doh.pub/dns-query'), + timeoutMs: toPositiveNumber(raw.timeoutMs, 5000), + maxAttempts: Math.floor(toPositiveNumber(raw.maxAttempts, 20)), + }; + } + + /** + * 读取 CNAME 目标(config.frontConfig.cname)。 + * + * 域名未通过验证时随 getDomain 返回给前端,提示用户把域名 CNAME 指向该目标。 + * + * @return {string} CNAME 目标;未配置返回空串。 + */ + getCnameTarget() { + const frontConfig = (this.app && this.app.config && this.app.config.frontConfig) || {}; + return String(frontConfig.cname || '').trim(); + } + + /** + * 生成域名验证所需的随机码(一次性校验子域 + TXT 记录值)。 + * + * 校验目标用一次性随机子域(wmsv-<10 位 hex>.<域名>)而非裸域名, + * 避免与用户主域上已有的其它 TXT 记录(SPF/DKIM/站点校验等)互相干扰。 + * + * @param {string} domain 已规范化的域名。 + * @return {Object} { host: 待校验 TXT 主机名, token: 待校验 TXT 记录值(32 位 hex) }。 + */ + buildDomainVerifyCode(domain) { + const randomTag = crypto.randomBytes(DOMAIN_VERIFY_HOST_RANDOM_BYTES).toString('hex'); + + return { + host: `${DOMAIN_VERIFY_HOST_PREFIX}${randomTag}.${domain}`, + token: crypto.randomBytes(DOMAIN_VERIFY_TOKEN_BYTES).toString('hex'), + }; + } + + /** + * 解析 DoH 应答中单条 TXT 记录的 data 文本(去外层引号、多段拼接、截断保护)。 + * + * DoH JSON 的 Answer[].data 形如 "abc" 或 "abc" "def"(TXT 单条记录可按 255 字节分段)。 + * + * @param {*} data DoH 应答中的 data 字段。 + * @return {string} 解析后的 TXT 文本;无内容返回空串。 + */ + parseTxtAnswerData(data) { + const text = String(data === undefined || data === null ? '' : data).trim(); + if (!text) { + return ''; + } + + const segments = text.match(/"([^"]*)"/g); + const value = segments && segments.length > 0 + ? segments.map(segment => segment.slice(1, -1)).join('') + : text.replace(/"/g, ''); + + return value.trim().slice(0, TXT_VALUE_MAX_LENGTH); + } + + /** + * 从 DoH 应答的 Answer 数组中提取 TXT 记录(type=16)。 + * + * @param {Array} answers DoH 应答的 Answer 数组。 + * @return {string[]} TXT 记录文本列表(已去空、截断)。 + */ + extractTxtValuesFromAnswers(answers) { + const values = []; + + for (const answer of Array.isArray(answers) ? answers : []) { + if (!answer || Number(answer.type) !== 16) { + continue; + } + + const value = this.parseTxtAnswerData(answer.data); + if (value) { + values.push(value); + } + } + + return values; + } + + /** + * DoH(DNS-over-HTTPS)解析 TXT 记录。 + * + * @param {string} host 待解析主机名。 + * @param {Object} verifyConfig 域名验证配置(getDomainVerifyConfig 返回值)。 + * @return {Promise} TXT 记录文本列表;无记录返回空数组。 + * @throws {Error} DoH 请求失败/响应异常时抛出(由 resolveTxtValues 决定是否降级)。 + */ + async resolveTxtByDoh(host, verifyConfig) { + const url = `${verifyConfig.dohUrl}?name=${encodeURIComponent(host)}&type=TXT`; + const response = await this.ctx.curl(url, { + method: 'GET', + headers: { accept: 'application/dns-json' }, + timeout: verifyConfig.timeoutMs, + dataType: 'json', + }); + + const statusCode = Number(response && response.status) || 0; + if (statusCode !== 200) { + throw new Error(`DoH 服务返回异常状态码 ${statusCode}`); + } + + const body = response && response.data; + if (!body || typeof body !== 'object') { + throw new Error('DoH 响应体不是合法 JSON'); + } + + // Status=3(NXDOMAIN)或 Status=0 但无 Answer 均视为「未解析到记录」, + // 返回空数组交给上层判定,不降级系统 DNS 重复查询 + return this.extractTxtValuesFromAnswers(body.Answer); + } + + /** + * 系统 DNS(node:dns)解析 TXT 记录,作为 DoH 的兜底路径。 + * + * @param {string} host 待解析主机名。 + * @return {Promise} TXT 记录文本列表(多段已拼接、去空、截断)。 + * @throws {Error} 解析失败(含 NXDOMAIN/超时)时抛出。 + */ + async resolveTxtBySystem(host) { + const records = await dns.promises.resolveTxt(host); + const values = []; + + for (const record of Array.isArray(records) ? records : []) { + const joined = Array.isArray(record) ? record.join('') : String(record || ''); + const value = joined.trim().slice(0, TXT_VALUE_MAX_LENGTH); + if (value) { + values.push(value); + } + } + + return values; + } + + /** + * 解析指定主机名的 TXT 记录(DoH 主路径,失败降级系统 DNS)。 + * + * 公共方法:app/schedule 下的域名验证定时任务会直接调用,签名与返回值需保持稳定。 + * + * @param {string} host 待解析主机名(域名验证一律传 domain_verify_host,不用裸域名)。 + * @return {Promise} { values: string[], source: 'doh'|'system' }。 + * @throws {Error} 两条路径均失败时抛出,状态码 500,文案已脱敏截断。 + */ + async resolveTxtValues(host) { + const normalizedHost = String(host || '').trim().toLowerCase(); + if (!normalizedHost) { + throw this.createError('域名解析主机名不能为空', 400); + } + + const verifyConfig = this.getDomainVerifyConfig(); + + try { + const values = await this.resolveTxtByDoh(normalizedHost, verifyConfig); + return { values, source: 'doh' }; + } catch (error) { + this.ctx.logger.warn( + '[FrontConfigService.resolveTxtValues] DoH 解析失败,降级系统 DNS: %s', + this.sanitizeErrorText(error.message) + ); + } + + try { + const values = await this.resolveTxtBySystem(normalizedHost); + return { values, source: 'system' }; + } catch (error) { + const reason = this.sanitizeErrorText(error.message) || '未知错误'; + throw this.createError(`DNS 解析失败:${reason}`, 500); + } + } + + /** + * 校验单行记录的域名 TXT 归属(定时任务逐行调用,必须失败隔离、不得抛异常)。 + * + * @param {Object} record 配置记录(需含 domain_verify_host / domain_verify_token)。 + * @return {Promise} 校验结果,字段如下: + * - verified {boolean}:是否校验通过(解析到的 TXT 记录中包含校验值); + * - values {string[]}:实际解析到的 TXT 值; + * - source {string}:解析来源 doh/system,未解析为空串; + * - error {string|null}:失败原因(已脱敏截断),成功为 null。 + */ + async verifyDomainRecord(record) { + const verifyHost = String(this.getRecordField(record, 'domain_verify_host') || '').trim(); + const verifyToken = String(this.getRecordField(record, 'domain_verify_token') || '').trim(); + + if (!verifyHost) { + return { verified: false, values: [], source: '', error: '未生成待校验的 TXT 主机名,请重新设置域名' }; + } + + if (!verifyToken) { + return { verified: false, values: [], source: '', error: '未生成待校验的 TXT 记录值,请重新设置域名' }; + } + + try { + const { values, source } = await this.resolveTxtValues(verifyHost); + const normalizedValues = values.map(value => String(value).trim()); + + // 校验值为后端生成的 hex,比对时忽略大小写(DNS 记录本身大小写不敏感) + const expected = verifyToken.toLowerCase(); + if (normalizedValues.some(value => value.toLowerCase() === expected)) { + return { verified: true, values: normalizedValues, source, error: null }; + } + + return { + verified: false, + values: normalizedValues, + source, + error: normalizedValues.length > 0 ? 'TXT 记录未包含校验值' : '未解析到 TXT 记录', + }; + } catch (error) { + return { + verified: false, + values: [], + source: '', + error: this.sanitizeErrorText(error.message) || '域名解析失败', + }; + } + } + + /** + * 判定错误是否为「数据库列不存在」(迁移尚未执行的典型表现)。 + * + * 迁移尚未执行时查询 domain_status 等新列会报 ER_BAD_FIELD_ERROR / Unknown column, + * 这类错误必须走降级路径(而非中断定时任务、也不应让公共拉取接口直接 500)。 + * + * @param {*} error 错误对象。 + * @return {boolean} 是未知列错误返回 true。 + */ + isUnknownColumnError(error) { + if (!error) { + return false; + } + + const code = String((error.parent && error.parent.code) || error.code || ''); + if (code === 'ER_BAD_FIELD_ERROR') { + return true; + } + + const message = String(error.message || ''); + return /unknown column/i.test(message) || message.includes('ER_BAD_FIELD_ERROR'); + } + + /** + * 查询「已验证」的域名配置记录(公共拉取闸门的查库入口)。 + * + * 迁移容错:迁移尚未执行(domain_status 列不存在)时降级为仅按 domain 查询, + * 保持迁移前的行为,并用进程内一次性标记避免刷日志; + * 迁移完成后需重启实例,闸门才会真正生效(进程内标记与 model 定义均在重启后刷新)。 + * + * @param {Object} configModel WarehouseFrontConfig model。 + * @param {string} normalizedDomain 已 trim 的域名。 + * @return {Promise} 命中返回记录实例,未命中返回 null。 + * @throws {Error} 非「未知列」的数据库异常原样抛出(由调用方转 500)。 + */ + async findVerifiedDomainRecord(configModel, normalizedDomain) { + try { + return await configModel.findOne({ + where: { + domain: normalizedDomain, + domain_status: DOMAIN_STATUS_VERIFIED, + }, + }); + } catch (error) { + if (!this.isUnknownColumnError(error)) { + throw error; + } + + // 一次性 WARN:迁移完成并重启实例后自动恢复闸门,避免每个请求都刷日志 + if (this.app && !this.app._frontConfigDomainStatusFallbackWarned) { + this.app._frontConfigDomainStatusFallbackWarned = true; + this.ctx.logger.warn( + '[FrontConfigService.findVerifiedDomainRecord] wms_warehouse_front_config.domain_status 列不存在' + + '(迁移尚未执行),本次降级为仅按 domain 查询;迁移完成后需重启实例才能恢复域名验证闸门' + ); + } + + return configModel.findOne({ + where: { + domain: normalizedDomain, + }, + }); + } + } + + /** + * 扫描并校验待验证的域名(供定时任务与手动触发复用)。 + * + * 选取条件:domain_verify_host 与 domain_verify_token 均非空、domain_status 为 0(未验证) + * 或 2(验证失败),且 domain_verify_attempts 未达 maxAttempts 上限;按 id 升序单批处理 + * batchSize 行。已达尝试上限的行不再自动重试,计入 skipped(仍可由 checkDomain 手动触发)。 + * + * 失败隔离:单行解析/落库失败只计入 errors,不中断整轮;onRow 回调抛错同样不影响主流程。 + * fail-soft:model 不可用、或迁移尚未执行(domain_status 等列不存在)时不抛出, + * 返回零统计 + errors 中的脱敏原因,由调用方记 WARN。 + * + * @param {Object} [options] 扫描选项。 + * @param {number} [options.batchSize] 单轮最多处理行数(默认取 domainVerify.batchSize)。 + * @param {number} [options.maxAttempts] 超过后不再自动重试(默认取 domainVerify.maxAttempts)。 + * @param {Function} [options.onRow] 每行处理后的回调(参数 { id, store_id, domain, verified, error })。 + * @return {Promise<{scanned:number, verified:number, failed:number, skipped:number, errors:string[]}>} + * scanned:本轮选中的待处理行数;verified:其中校验通过且落库成功的行数; + * failed:校验失败且落库成功的行数;skipped:因达到 maxAttempts 上限而未自动重试的行数; + * errors:脱敏后的错误原因列表。 + */ + async verifyPendingDomains(options = {}) { + const verifyConfig = this.getDomainVerifyConfig(); + const batchSize = Number(options.batchSize) > 0 + ? Math.floor(Number(options.batchSize)) + : verifyConfig.batchSize; + const maxAttempts = Number(options.maxAttempts) > 0 + ? Math.floor(Number(options.maxAttempts)) + : verifyConfig.maxAttempts; + const onRow = typeof options.onRow === 'function' ? options.onRow : null; + + const summary = { scanned: 0, verified: 0, failed: 0, skipped: 0, errors: [] }; + + const configModel = this.ctx.model && this.ctx.model.WarehouseFrontConfig; + if (!configModel || typeof configModel.findAll !== 'function') { + summary.errors.push('WarehouseFrontConfig model 不可用'); + return summary; + } + + const { Op } = this.app.Sequelize; + const pendingWhere = { + domain_verify_host: { [Op.ne]: null }, + domain_verify_token: { [Op.ne]: null }, + domain_status: { [Op.in]: [ DOMAIN_STATUS_UNVERIFIED, DOMAIN_STATUS_FAILED ] }, + }; + + let rows = []; + try { + rows = await configModel.findAll({ + where: { + ...pendingWhere, + domain_verify_attempts: { [Op.lt]: maxAttempts }, + }, + attributes: [ + 'id', + 'store_id', + 'domain', + 'domain_status', + 'domain_verify_host', + 'domain_verify_token', + 'domain_verify_attempts', + 'domain_last_error', + ], + order: [[ 'id', 'ASC' ]], + limit: batchSize, + raw: true, + }); + } catch (error) { + const reason = this.sanitizeErrorText(error.message) || '未知错误'; + this.ctx.logger.warn('[FrontConfigService.verifyPendingDomains] 查询待验证域名失败: %s', reason); + summary.errors.push('查询待验证域名失败:' + reason); + return summary; + } + + // 已达上限的行不再自动重试,单独计数便于观察「自动重试已耗尽」的域名规模; + // 计数失败不影响主流程(计入 errors 即可) + try { + summary.skipped = await configModel.count({ + where: { + ...pendingWhere, + domain_verify_attempts: { [Op.gte]: maxAttempts }, + }, + }); + } catch (error) { + const reason = this.sanitizeErrorText(error.message) || '未知错误'; + this.ctx.logger.warn('[FrontConfigService.verifyPendingDomains] 统计已达重试上限行数失败: %s', reason); + summary.errors.push('统计已达重试上限行数失败:' + reason); + } + + summary.scanned = rows.length; + + for (const row of rows) { + const rowId = Number(row.id); + const rowDomain = String(row.domain || '').trim(); + const currentAttempts = Number(row.domain_verify_attempts) || 0; + let result = { verified: false, error: '未解析到 TXT 记录' }; + + try { + // verifyDomainRecord 契约上不抛异常,此处为最后一道兜底,保证单行失败不中断整轮 + result = await this.verifyDomainRecord(row); + } catch (error) { + result = { verified: false, error: this.sanitizeErrorText(error.message) || '域名校验异常' }; + } + + let updateValues; + if (result.verified) { + updateValues = { + domain_status: DOMAIN_STATUS_VERIFIED, + domain_verified_at: new Date(), + domain_last_error: null, + domain_verify_attempts: currentAttempts + 1, + }; + } else { + updateValues = { + domain_status: DOMAIN_STATUS_FAILED, + domain_verify_attempts: currentAttempts + 1, + domain_last_error: this.sanitizeErrorText(result.error || '未解析到 TXT 记录'), + }; + } + + try { + // 防并发守卫:仅更新 id 与 domain 均匹配的行,避免与并发校验者互相覆盖 + await configModel.update(updateValues, { + where: { id: rowId, domain: row.domain }, + }); + + if (result.verified) { + summary.verified += 1; + // 未验证域名本不会被公共拉取放行,成功后仍主动清一次缓存更稳妥 + await this.clearDomainCache(rowDomain); + } else { + summary.failed += 1; + } + } catch (error) { + const reason = this.sanitizeErrorText(error.message) || '未知错误'; + summary.errors.push('更新域名验证状态失败(id=' + rowId + '):' + reason); + this.ctx.logger.warn( + '[FrontConfigService.verifyPendingDomains] 更新域名验证状态失败 id=%s: %s', + rowId, + reason + ); + } + + if (onRow) { + try { + await onRow({ + id: rowId, + store_id: Number(row.store_id) || 0, + domain: rowDomain, + verified: !!result.verified, + error: result.verified ? null : this.sanitizeErrorText(result.error || ''), + }); + } catch (error) { + // 回调异常只 WARN,绝不影响主流程 + this.ctx.logger.warn( + '[FrontConfigService.verifyPendingDomains] onRow 回调执行失败 id=%s: %s', + rowId, + this.sanitizeErrorText(error.message) + ); + } + } + } + + return summary; + } + + /** + * 构建前端配置品牌信息输出对象(settings 页回显,无记录时返回默认空值)。 + * + * 安全红线:仅输出品牌与基础字段,严禁输出 cert_pem/key_pem/cert_expire_at/ + * sync_status/sync_attempts/last_sync_error/last_synced_at 等证书与同步内部字段。 + * + * @param {Object|null} record 配置记录实例(可为 null)。 + * @param {number} warehouseId 当前仓库 ID。 + * @return {Object} 品牌信息输出对象(warehouse_id/domain/title/logo_url/favicon_url/login_bg_url/theme/updated_at)。 + */ + buildInfoOutput(record, warehouseId) { + const hasRecord = !!(record && typeof record.get === 'function'); + const getValue = key => (hasRecord ? record.get(key) : null); + + return { + warehouse_id: Number(warehouseId || 0), + domain: hasRecord ? (getValue('domain') || '') : '', + title: hasRecord ? (getValue('title') || '') : '', + logo_url: hasRecord ? (getValue('logo_url') || '') : '', + favicon_url: hasRecord ? (getValue('favicon_url') || '') : '', + login_bg_url: hasRecord ? (getValue('login_bg_url') || '') : '', + theme: hasRecord ? (getValue('theme') || null) : null, + updated_at: hasRecord ? (getValue('updated_at') || null) : null, + }; + } + + /** + * 构建前端配置证书输出对象(证书/私钥原文回显,无记录时返回默认空值)。 + * + * 证书回显:输出证书原文(cert_pem)与私钥原文(key_pem,取自 cert_key 列), + * 不再输出 cert_path/key_path 路径字段(保存时已置空,尚无真实路径)。 + * 安全说明:私钥原文回显仅限仓库主体登录后的 settings 页(getCert/saveCert + * 复用本输出);公共无鉴权接口 getByDomain 走 buildPublicOutput 白名单,不经过本方法。 + * + * ⚠ 响应契约:本方法输出 13 个字段(原有 10 个 + 本次新增 3 个),文档与测试需同步。 + * 原有 10 字段:warehouse_id/domain/cert_pem/key_pem/cert_expire_at/sync_status/ + * sync_attempts/last_sync_error/last_synced_at/updated_at。 + * 新增 3 字段(追加在末尾): + * - domain_status:域名验证状态 0-未验证/1-已验证/2-验证失败; + * - can_set_cert:域名非空且已验证(domain_status=1)才允许上传证书; + * - can_set_cert_reason:不可上传时的原因,可上传为空串。 + * + * @param {Object|null} record 配置记录实例(可为 null)。 + * @param {number} warehouseId 当前仓库 ID。 + * @return {Object} 证书输出对象(13 字段)。 + */ + buildCertOutput(record, warehouseId) { + const hasRecord = !!(record && typeof record.get === 'function'); + const getValue = key => (hasRecord ? record.get(key) : null); + + const domain = hasRecord ? (getValue('domain') || '') : ''; + const domainStatus = hasRecord ? Number(getValue('domain_status') || 0) : DOMAIN_STATUS_UNVERIFIED; + // 上传证书的前置闸门:必须先设置域名并通过 DNS TXT 验证 + const canSetCert = !!domain && domainStatus === DOMAIN_STATUS_VERIFIED; + + let canSetCertReason = ''; + if (!domain) { + canSetCertReason = '请先设置域名'; + } else if (!canSetCert) { + canSetCertReason = this.describeDomainStatus(domainStatus); + } + + return { + warehouse_id: Number(warehouseId || 0), + domain: hasRecord ? (getValue('domain') || '') : '', + cert_pem: hasRecord ? (getValue('cert_pem') || '') : '', + key_pem: hasRecord ? (getValue('cert_key') || '') : '', + cert_expire_at: hasRecord ? (getValue('cert_expire_at') || null) : null, + sync_status: hasRecord ? Number(getValue('sync_status') || 0) : 0, + sync_attempts: hasRecord ? Number(getValue('sync_attempts') || 0) : 0, + last_sync_error: hasRecord ? (getValue('last_sync_error') || '') : '', + last_synced_at: hasRecord ? (getValue('last_synced_at') || null) : null, + updated_at: hasRecord ? (getValue('updated_at') || null) : null, + can_set_cert: canSetCert, + can_set_cert_reason: canSetCertReason, + domain_status: domainStatus, + }; + } + + /** + * 查询当前仓库前端独立部署品牌配置(settings 页回显)。 + * + * 需登录(token 绑定仓库上下文,只能查到自己仓库的配置),仅返回品牌与基础字段, + * 不含证书/私钥原文与同步状态等内部字段(证书回显走 getCert)。 + * + * @return {Promise} 品牌信息输出对象;无记录时返回默认空值。 + * @throws {Error} 未识别到当前仓库时抛出 400;非仓库主体时抛出 403。 + */ + async getInfo() { + const warehouseId = this.getCurrentWarehouseId(); + + // 仅仓库主体管理员可查看前端独立部署配置(isWarehouse 判定) + await this.assertWarehouseSubject(); + + const configModel = this.ctx.model && this.ctx.model.WarehouseFrontConfig; + if (!configModel || typeof configModel.findOne !== 'function') { + throw this.createError('WarehouseFrontConfig model 不可用', 500); + } + + const record = await configModel.findOne({ + where: { + store_id: warehouseId, + }, + }); + + return this.buildInfoOutput(record, warehouseId); + } + + /** + * 查询当前仓库前端独立部署证书配置(settings 页回显)。 + * + * 需登录(token 绑定仓库上下文,只能查到自己仓库的配置), + * 响应含证书原文(cert_pem)与私钥原文(key_pem),仅供仓库主体 settings 页回显; + * 公共无鉴权接口 getByDomain 仍只返回公开字段白名单。 + * + * @return {Promise} 证书输出对象;无记录时返回默认空值。 + * @throws {Error} 未识别到当前仓库时抛出 400;非仓库主体时抛出 403。 + */ + async getCert() { + const warehouseId = this.getCurrentWarehouseId(); + + // 仅仓库主体管理员可查看前端独立部署证书(isWarehouse 判定) + await this.assertWarehouseSubject(); + + const configModel = this.ctx.model && this.ctx.model.WarehouseFrontConfig; + if (!configModel || typeof configModel.findOne !== 'function') { + throw this.createError('WarehouseFrontConfig model 不可用', 500); + } + + const record = await configModel.findOne({ + where: { + store_id: warehouseId, + }, + }); + + return this.buildCertOutput(record, warehouseId); + } + + /** + * 查询当前仓库域名验证状态(settings 页回显,需登录、仅仓库主体)。 + * + * 需登录(token 绑定仓库上下文,只能查到自己仓库的配置);无记录时返回空值默认。 + * + * @return {Promise} 域名输出对象(warehouse_id/domain/domain_status/verify_host/ + * verify_value/cname/verified_at/attempts/last_error)。 + * @throws {Error} 未识别到当前仓库时抛出 400;非仓库主体时抛出 403。 + */ + async getDomain() { + const warehouseId = this.getCurrentWarehouseId(); + + // 仅仓库主体管理员可查看前端独立部署域名配置(isWarehouse 判定) + await this.assertWarehouseSubject(); + + const configModel = this.ctx.model && this.ctx.model.WarehouseFrontConfig; + if (!configModel || typeof configModel.findOne !== 'function') { + throw this.createError('WarehouseFrontConfig model 不可用', 500); + } + + const record = await configModel.findOne({ + where: { + store_id: warehouseId, + }, + }); + + return this.buildDomainOutput(record, warehouseId); + } + + /** + * 设置当前仓库自持域名并下发一次性 TXT 校验记录(需登录、仅仓库主体)。 + * + * 流程:仓库主体校验 → domain 非空/长度/形态校验(统一转小写)→ 全局唯一校验(409) + * → 生成随机校验子域与校验值 → upsert 该仓库行 → 清理新旧域名公共拉取缓存。 + * 域名发生变更(含从无到有)会同时清空既有证书与同步状态:旧证书 SAN/CN 不覆盖新域名, + * 保留会让 nginx 用错误证书对外服务;域名未变化时保留既有证书与验证状态。 + * + * @param {Object} [data={}] 请求参数。 + * @param {string} data.domain 仓库自持域名(必填,非空,≤100 字符,全局唯一)。 + * @return {Promise} 域名输出对象(含待配置的 verify_host/verify_value 与 cname)。 + * @throws {Error} 未识别到当前仓库时抛出 400;非仓库主体时抛出 403; + * 参数非法时抛出 400;域名被其他仓库占用时抛出 409。 + */ + async setDomain(data = {}) { + const warehouseId = this.getCurrentWarehouseId(); + + // 仅仓库主体管理员可配置前端独立部署域名(isWarehouse 判定) + await this.assertWarehouseSubject(); + + const configModel = this.ctx.model && this.ctx.model.WarehouseFrontConfig; + if (!configModel || typeof configModel.findOne !== 'function') { + throw this.createError('WarehouseFrontConfig model 不可用', 500); + } + + const domain = this.normalizeText(data.domain, 'domain', 100); + if (!domain) { + throw this.createError('domain 不能为空', 400); + } + + // 统一转小写存储:DNS 大小写不敏感,避免同一域名靠大小写差异绕过去重校验 + const normalizedDomain = domain.toLowerCase(); + if (!DOMAIN_PATTERN.test(normalizedDomain)) { + throw this.createError('domain 格式不正确', 400); + } + + // domain 全局唯一:可空列唯一索引不拦多个 NULL,非空值的唯一性必须应用层校验 + await this.assertDomainUnique(normalizedDomain, warehouseId); + + const record = await configModel.findOne({ + where: { + store_id: warehouseId, + }, + }); + + const previousDomain = record ? String(record.get('domain') || '').trim() : ''; + // 仅大小写差异不算域名变更:避免单纯规范化大小写就把仍在有效期内的证书清掉 + const domainChanged = previousDomain.toLowerCase() !== normalizedDomain; + + // 重复设置同一已验证域名:幂等返回,不刷新校验码、不清证书、不重置验证状态 + if (record && !domainChanged && Number(record.get('domain_status') || 0) === DOMAIN_STATUS_VERIFIED) { + return this.buildDomainOutput(record, warehouseId); + } + + // 首次设置/域名变更/尚未验证:下发新的校验码并回到「未验证」,清零历史尝试次数与失败原因 + const verifyCode = this.buildDomainVerifyCode(normalizedDomain); + const patch = { + domain: normalizedDomain, + domain_verify_host: verifyCode.host, + domain_verify_token: verifyCode.token, + domain_status: DOMAIN_STATUS_UNVERIFIED, + domain_verify_attempts: 0, + domain_verified_at: null, + domain_last_error: null, + }; + + if (domainChanged) { + // 域名变更:既有证书对新域名不再有效,必须一并清空并重置同步状态, + // 避免 nginx 继续用旧域名证书对外服务(证书与域名不匹配) + Object.assign(patch, { + cert_pem: null, + cert_key: null, + cert_path: null, + key_path: null, + cert_expire_at: null, + sync_status: 0, + sync_attempts: 0, + last_sync_error: null, + last_synced_at: null, + }); + } + + let savedRecord = record; + try { + if (record) { + await record.update(patch); + } else { + savedRecord = await configModel.create({ + store_id: warehouseId, + ...patch, + }); + } + } catch (error) { + // 并发写入兜底:唯一索引冲突统一转为业务错误 + if (error && error.name === 'SequelizeUniqueConstraintError') { + const conflictFields = error.fields || {}; + if (Object.prototype.hasOwnProperty.call(conflictFields, 'domain')) { + throw this.createError(`域名 ${normalizedDomain} 已被其他仓库使用`, 409); + } + throw this.createError('仓库前端配置保存冲突,请稍后重试', 409); + } + throw error; + } + + // 回查一次再输出,避免实例上残留 CURRENT_TIMESTAMP 等字面量 + const refreshedRecord = await configModel.findByPk(savedRecord.id); + + // 写库成功后清理公共拉取缓存(先写库后清缓存):域名变更时新旧两个 domain 都必须清, + // 否则旧域名的公开配置缓存仍会对外返回;清缓存失败仅记日志,不影响设置结果 + const affectedDomains = [ ...new Set([ previousDomain, normalizedDomain ].filter(item => item)) ]; + await Promise.all(affectedDomains.map(affectedDomain => this.clearDomainCache(affectedDomain) + .catch(error => { + this.ctx.logger.warn('[FrontConfigService.setDomain] 清理前端配置缓存失败: %s', error.message); + }))); + + return this.buildDomainOutput(refreshedRecord, warehouseId); + } + + /** + * 主动执行一次域名 TXT 校验并回写结果(需登录、仅仓库主体)。 + * + * 无记录或 domain 为空时返回 400 提示先设置域名;校验通过置 domain_status=1 + * 并记录 domain_verified_at;失败置 domain_status=2、尝试次数 +1 并记录脱敏后的失败原因。 + * 校验一律以库内 domain_verify_host 为目标(不用裸域名),避免与用户主域其它 TXT 记录冲突。 + * + * @return {Promise} 域名输出对象 + verified(本次是否通过) + * + resolved_values(本次解析到的 TXT 值,最多 5 条)。 + * @throws {Error} 未识别到当前仓库时抛出 400;未设置域名时抛出 400;非仓库主体时抛出 403。 + */ + async checkDomain() { + const warehouseId = this.getCurrentWarehouseId(); + + // 仅仓库主体管理员可触发域名校验(isWarehouse 判定) + await this.assertWarehouseSubject(); + + const configModel = this.ctx.model && this.ctx.model.WarehouseFrontConfig; + if (!configModel || typeof configModel.findOne !== 'function') { + throw this.createError('WarehouseFrontConfig model 不可用', 500); + } + + const record = await configModel.findOne({ + where: { + store_id: warehouseId, + }, + }); + + const domain = record ? String(record.get('domain') || '').trim() : ''; + if (!domain) { + throw this.createError('请先设置域名', 400); + } + + const domainStatus = Number(record.get('domain_status') || 0); + const currentHost = String(record.get('domain_verify_host') || '').trim(); + const currentToken = String(record.get('domain_verify_token') || '').trim(); + + // 兼容迁移回填的历史行:域名线上已生效(直接视为已验证)但从未生成校验记录, + // 无法也无需重新校验;此处直接返回已验证,避免手动点校验把生效中的域名降级为验证失败 + if (domainStatus === DOMAIN_STATUS_VERIFIED && (!currentHost || !currentToken)) { + return { + ...this.buildDomainOutput(record, warehouseId), + verified: true, + resolved_values: [], + }; + } + + const patch = {}; + let verifyHost = currentHost; + let verifyToken = currentToken; + + // 未验证/验证失败且库内缺少校验码(历史脏数据):补发一份, + // 用户配置 DNS 解析后再次校验即可通过(本次校验仍会因记录未生效而失败) + if (!verifyHost || !verifyToken) { + const verifyCode = this.buildDomainVerifyCode(domain); + verifyHost = verifyCode.host; + verifyToken = verifyCode.token; + patch.domain_verify_host = verifyHost; + patch.domain_verify_token = verifyToken; + } + + const verifyResult = await this.verifyDomainRecord({ + domain_verify_host: verifyHost, + domain_verify_token: verifyToken, + }); + + if (verifyResult.verified) { + patch.domain_status = DOMAIN_STATUS_VERIFIED; + patch.domain_verified_at = new Date(); + patch.domain_last_error = null; + } else { + patch.domain_status = DOMAIN_STATUS_FAILED; + patch.domain_verify_attempts = Number(record.get('domain_verify_attempts') || 0) + 1; + patch.domain_last_error = this.sanitizeErrorText(verifyResult.error) || '域名验证失败'; + } + + await record.update(patch); + + // 回查一次再输出,避免实例上残留 CURRENT_TIMESTAMP 等字面量 + const savedRecord = await configModel.findByPk(record.id); + + return { + ...this.buildDomainOutput(savedRecord, warehouseId), + verified: !!verifyResult.verified, + resolved_values: (Array.isArray(verifyResult.values) ? verifyResult.values : []) + .slice(0, DOMAIN_RESOLVED_VALUES_LIMIT) + .map(value => String(value).slice(0, DOMAIN_RESOLVED_VALUE_MAX_LENGTH)), + }; + } + + /** + * 构建域名验证输出对象(getDomain/setDomain/checkDomain 共用)。 + * + * 安全口径:domain_status === 1(已验证)时不再回显校验主机名与校验值(令牌已无用途); + * 未验证/验证失败时回显,供用户配置 DNS TXT 解析记录。 + * + * @param {Object|null} record 配置记录实例(可为 null,返回空值默认)。 + * @param {number} warehouseId 当前仓库 ID。 + * @return {Object} 域名输出对象(warehouse_id/domain/domain_status/verify_host/verify_value/cname/verified_at/attempts/last_error)。 + */ + buildDomainOutput(record, warehouseId) { + const hasRecord = !!(record && typeof record.get === 'function'); + const getValue = key => (hasRecord ? record.get(key) : null); + + const domain = hasRecord ? String(getValue('domain') || '').trim() : ''; + const domainStatus = hasRecord ? Number(getValue('domain_status') || 0) : DOMAIN_STATUS_UNVERIFIED; + const exposeVerifyInfo = !!domain && domainStatus !== DOMAIN_STATUS_VERIFIED; + + return { + warehouse_id: Number(warehouseId || 0), + domain, + domain_status: domainStatus, + verify_host: exposeVerifyInfo ? String(getValue('domain_verify_host') || '') : '', + verify_value: exposeVerifyInfo ? String(getValue('domain_verify_token') || '') : '', + cname: this.getCnameTarget(), + verified_at: hasRecord ? (getValue('domain_verified_at') || null) : null, + attempts: hasRecord ? Number(getValue('domain_verify_attempts') || 0) : 0, + last_error: hasRecord ? String(getValue('domain_last_error') || '') : '', + }; + } + + /** + * 域名状态→前端可读文案(用于 can_set_cert_reason,已验证返回空串)。 + * + * @param {number} domainStatus 域名验证状态。 + * @return {string} 状态文案。 + */ + describeDomainStatus(domainStatus) { + if (Number(domainStatus) === DOMAIN_STATUS_VERIFIED) { + return ''; + } + + if (Number(domainStatus) === DOMAIN_STATUS_FAILED) { + return '域名验证失败'; + } + + return '域名待验证'; + } + + /** + * 构建前端配置公共拉取接口的缓存键(按域名)。 + * + * @param {string} domain 域名(内部会 trim 规范化)。 + * @return {string} Redis 缓存键。 + */ + getDomainCacheKey(domain) { + return `front:config:domain:${String(domain || '').trim()}`; + } + + /** + * 构建前端配置公共拉取接口的输出对象(仅公开字段白名单)。 + * + * 安全红线:只输出 PUBLIC_FIELDS 白名单字段, + * 严禁输出 cert_pem/cert_key 证书与私钥内容,以及 cert_path、key_path、 + * sync_status、sync_attempts、last_sync_error 等内部字段。 + * + * @param {Object} record 配置记录实例。 + * @return {Object} 仅含公开字段的输出对象。 + */ + buildPublicOutput(record) { + const hasRecord = !!(record && typeof record.get === 'function'); + const getValue = key => (hasRecord ? record.get(key) : null); + + const output = {}; + for (const key of PUBLIC_FIELDS) { + const value = hasRecord ? getValue(key) : null; + output[key] = key === 'theme' ? (value || null) : (value || ''); + } + return output; + } + + /** + * 清理指定域名的前端配置公共拉取缓存(空域名跳过)。 + * + * @param {string} domain 待清理的域名。 + * @return {Promise} 无返回值。 + */ + async clearDomainCache(domain) { + const normalizedDomain = String(domain || '').trim(); + if (!normalizedDomain) { + return; + } + + await this.deleteCacheByKey(this.getDomainCacheKey(normalizedDomain)); + } + + /** + * 按域名查询前端配置(公共无鉴权接口业务实现,Redis 缓存 + 查库兜底)。 + * + * 安全红线:只返回公开字段(domain/title/logo_url/login_bg_url/favicon_url/theme), + * 严禁返回 cert_pem/cert_key 证书与私钥内容,以及 cert_path/key_path/ + * sync_status/sync_attempts/last_sync_error 等内部字段。 + * + * @param {string} domain 待查询域名。 + * @return {Promise} 仅含公开字段的配置对象。 + * @throws {Error} domain 为空时抛出 400;未登记域名抛出 404;数据库异常抛出 500。 + */ + async getByDomain(domain) { + const normalizedDomain = String(domain || '').trim(); + + if (!normalizedDomain) { + throw this.createError('domain 不能为空', 400); + } + + if (normalizedDomain.length > 100) { + throw this.createError('domain 长度不能超过 100 字符', 400); + } + + const cacheKey = this.getDomainCacheKey(normalizedDomain); + + // 缓存取舍:命中缓存后 TTL(PUBLIC_CACHE_TTL_SECONDS = 600s)内直接返回, + // 若该行随后被置为「未验证」,理论上最长仍有 600s 会被放行; + // 但 setDomain / saveCert / 域名验证扫描成功均已调用 clearDomainCache 主动失效, + // 实际可通过缓存被放行的窗口很短,接受该取舍。 + // 优先读缓存;Redis 异常时降级查库(getCacheAsync 内部已做 Redis 降级处理) + if (this.app && typeof this.app.getCacheAsync === 'function') { + try { + const cached = await this.app.getCacheAsync(cacheKey); + + // 未登记域名空缓存标记:直接按未配置返回,防穿透 + if (cached && typeof cached === 'object' && cached.configured === false) { + throw this.createError('域名未配置', 404); + } + + if (cached && typeof cached === 'object' && typeof cached.domain === 'string' && cached.domain) { + return cached; + } + } catch (error) { + if (Number(error.code) === 404) { + throw error; + } + this.ctx.logger.warn('[FrontConfigService.getByDomain] 读取缓存失败,降级查库: %s', error.message); + } + } + + const configModel = this.ctx.model && this.ctx.model.WarehouseFrontConfig; + if (!configModel || typeof configModel.findOne !== 'function') { + throw this.createError('WarehouseFrontConfig model 不可用', 500); + } + + // 应用层闸门:只放行 domain_status = 1(已验证)的域名; + // 迁移尚未执行时 findVerifiedDomainRecord 内部降级为仅按 domain 查询(保持迁移前行为) + const record = await this.findVerifiedDomainRecord(configModel, normalizedDomain); + + if (!record) { + // 缓存穿透兜底:未登记域名写短 TTL 空缓存,防止高频探测打穿数据库 + if (this.app && typeof this.app.setCacheAsync === 'function') { + try { + await this.app.setCacheAsync(cacheKey, { configured: false }, PUBLIC_MISS_CACHE_TTL_SECONDS); + } catch (error) { + this.ctx.logger.warn('[FrontConfigService.getByDomain] 写入未命中空缓存失败: %s', error.message); + } + } + throw this.createError('域名未配置', 404); + } + + const output = this.buildPublicOutput(record); + + if (this.app && typeof this.app.setCacheAsync === 'function') { + try { + await this.app.setCacheAsync(cacheKey, output, PUBLIC_CACHE_TTL_SECONDS); + } catch (error) { + this.ctx.logger.warn('[FrontConfigService.getByDomain] 写入缓存失败: %s', error.message); + } + } + + return output; + } + + /** + * 规范化证书/私钥 PEM 文本:去首尾空白,空值返回 null(表示未提供)。 + * + * @param {*} value 原始值(PEM 文本)。 + * @param {string} fieldName 字段名(用于错误提示)。 + * @return {string|null} 规范化后的 PEM 文本;空值返回 null。 + * @throws {Error} 内容超过长度上限时抛出,状态码 400。 + */ + normalizePem(value, fieldName) { + if (value === undefined || value === null) { + return null; + } + + const normalized = String(value).trim(); + if (!normalized) { + return null; + } + + if (normalized.length > PEM_MAX_LENGTH) { + throw this.createError(`${fieldName} 内容长度不能超过 ${PEM_MAX_LENGTH} 字符`, 400); + } + + return normalized; + } + + /** + * 用 Node 内置 crypto.X509Certificate 解析证书 PEM 文本。 + * + * @param {string} certPem 证书 PEM 文本。 + * @return {Object} 解析成功后的 X509Certificate 实例。 + * @throws {Error} 证书无法解析时抛出,状态码 400,统一文案“证书不合法”。 + */ + parseCertPem(certPem) { + try { + return new crypto.X509Certificate(certPem); + } catch (error) { + throw this.createError('证书不合法', 400); + } + } + + /** + * 校验证书有效期:未生效或已过期的证书禁止提交。 + * + * @param {Object} cert 已解析的 X509Certificate 实例。 + * @return {void} 无返回值。 + * @throws {Error} 证书未生效或已过期时抛出,状态码 400,统一文案“证书不合法”。 + */ + assertCertValid(cert) { + const now = Date.now(); + const validFrom = new Date(cert.validFrom); + const validTo = new Date(cert.validTo); + + if (Number.isNaN(validFrom.getTime())) { + throw this.createError('证书不合法', 400); + } + + if (validFrom.getTime() > now) { + throw this.createError('证书不合法', 400); + } + + if (Number.isNaN(validTo.getTime())) { + throw this.createError('证书不合法', 400); + } + + if (validTo.getTime() <= now) { + throw this.createError('证书不合法', 400); + } + } + + /** + * 收集证书可覆盖的域名列表:SAN 中的 DNS 项与 CN,统一转小写。 + * + * @param {Object} cert 已解析的 X509Certificate 实例。 + * @return {string[]} 小写域名列表。 + */ + collectCertNames(cert) { + const names = []; + + const sanText = cert.subjectAltName || ''; + for (const part of String(sanText).split(',')) { + const entry = String(part).trim(); + if (entry.startsWith('DNS:')) { + const dnsName = entry.slice(4).trim(); + if (dnsName) { + names.push(dnsName.toLowerCase()); + } + } + } + + const subjectText = cert.subject || ''; + const cnMatch = /CN\s*=\s*([^,\n]+)/i.exec(String(subjectText)); + if (cnMatch && cnMatch[1]) { + names.push(cnMatch[1].trim().toLowerCase()); + } + + return names; + } + + /** + * 判断证书域名列表是否覆盖目标域名(支持精确匹配与通配符 *.example.com)。 + * + * @param {string[]} names 证书 SAN/CN 域名列表(小写)。 + * @param {string} domain 待校验域名。 + * @return {boolean} 是否覆盖。 + */ + certCoversDomain(names, domain) { + const target = String(domain).toLowerCase(); + if (!target) { + return true; + } + + return names.some(name => { + const normalized = String(name).toLowerCase(); + if (normalized === target) { + return true; + } + + if (normalized.startsWith('*.')) { + const suffix = normalized.slice(1); + if (!target.endsWith(suffix)) { + return false; + } + const prefix = target.slice(0, target.length - suffix.length); + return prefix.length > 0 && !prefix.includes('.'); + } + + return false; + }); + } + + /** + * 校验私钥与证书是否成对:对比两者的 SPKI DER 公钥指纹。 + * + * @param {string} keyPem 私钥 PEM 文本。 + * @param {Object} cert 已解析的 X509Certificate 实例。 + * @return {void} 无返回值。 + * @throws {Error} 私钥无法解析或与证书不匹配时抛出,状态码 400,统一文案“证书不合法”。 + */ + validateKeyPem(keyPem, cert) { + let publicKey; + try { + publicKey = crypto.createPublicKey(keyPem); + } catch (error) { + throw this.createError('证书不合法', 400); + } + + const keySpki = publicKey.export({ type: 'spki', format: 'der' }); + const certSpki = cert.publicKey.export({ type: 'spki', format: 'der' }); + if (Buffer.compare(keySpki, certSpki) !== 0) { + throw this.createError('证书不合法', 400); + } + } + + /** + * 校验当前主体为仓库主体(前端独立部署配置仅仓库主体可操作)。 + * + * @return {Promise} 当前主体对象(含 id/company_name/project/isWarehouse/status)。 + * @throws {Error} 签约关系服务不可用时抛出 500;非仓库主体时抛出 403。 + */ + async assertWarehouseSubject() { + const storeWarehouseService = this.ctx.service && this.ctx.service.systems && this.ctx.service.systems.storeWarehouse; + if (!storeWarehouseService || typeof storeWarehouseService.getCurrentSubject !== 'function') { + throw this.createError('签约关系服务不可用', 500); + } + + const currentSubject = await storeWarehouseService.getCurrentSubject(); + if (!currentSubject || !currentSubject.isWarehouse) { + throw this.createError('仅仓库主体可配置前端独立部署', 403); + } + + return currentSubject; + } + + /** + * 保存当前仓库前端独立部署品牌配置(upsert,一仓一行,仅品牌字段部分更新)。 + * + * 域名与证书不在本接口受理范围:domain 变更必须走 setDomain(并重新通过域名验证); + * cert_pem/key_pem/cert_path/key_path/cert_expire_at 一律不受理(方法层白名单过滤)。 + * 保存仍视为一次配置变更:同步状态重置为待同步,写库成功后清理当前 domain 的公共拉取缓存。 + * + * @param {Object} [data={}] 请求参数。 + * @param {string} [data.title] 站点标题(≤100 字符,空值清空)。 + * @param {string} [data.logo_url] Logo 地址(≤255 字符,空值清空)。 + * @param {string} [data.favicon_url] 站点 favicon 图标地址(≤255 字符,空值清空)。 + * @param {string} [data.login_bg_url] 登录页背景图地址(≤255 字符,空值清空)。 + * @param {Object|string} [data.theme] 主题配置(合法 JSON 对象或 JSON 字符串,空值清空)。 + * @return {Promise} 保存后的品牌信息输出对象(同步状态已重置为待同步;不含证书/私钥字段)。 + * @throws {Error} 非仓库主体时抛出 403;参数非法时抛出 400。 + */ + async saveInfo(data = {}) { + const warehouseId = this.getCurrentWarehouseId(); + + // 仅仓库主体管理员可配置前端独立部署(isWarehouse 判定) + await this.assertWarehouseSubject(); + + const configModel = this.ctx.model && this.ctx.model.WarehouseFrontConfig; + if (!configModel || typeof configModel.findOne !== 'function') { + throw this.createError('WarehouseFrontConfig model 不可用', 500); + } + + const patch = {}; + + for (const field of TEXT_FIELDS) { + if (Object.prototype.hasOwnProperty.call(data, field.key)) { + patch[field.key] = this.normalizeText(data[field.key], field.name, field.maxLength); + } + } + + if (Object.prototype.hasOwnProperty.call(data, 'theme')) { + patch.theme = this.normalizeTheme(data.theme); + } + + // 保存即重置同步状态:本次保存待同步 + patch.sync_status = 0; + patch.sync_attempts = 0; + patch.last_sync_error = null; + patch.last_synced_at = null; + + let record = await configModel.findOne({ + where: { + store_id: warehouseId, + }, + }); + + // 品牌字段不改变 domain:写库成功后清理当前 domain 的公共拉取缓存即可 + const previousDomain = record ? String(record.get('domain') || '').trim() : ''; + + try { + if (record) { + await record.update(patch); + } else { + record = await configModel.create({ + store_id: warehouseId, + ...patch, + }); + } + } catch (error) { + // 并发写入兜底:唯一索引冲突统一转为业务错误 + if (error && error.name === 'SequelizeUniqueConstraintError') { + throw this.createError('仓库前端配置保存冲突,请稍后重试', 409); + } + throw error; + } + + // 回查一次再输出,避免实例上残留 CURRENT_TIMESTAMP 等字面量 + const savedRecord = await configModel.findByPk(record.id); + + // 写库成功后清理公共拉取缓存(先写库后清缓存);清缓存失败仅记日志,不影响保存结果 + if (previousDomain) { + await this.clearDomainCache(previousDomain) + .catch(error => { + this.ctx.logger.warn('[FrontConfigService.saveInfo] 清理前端配置缓存失败: %s', error.message); + }); + } + + return this.buildInfoOutput(savedRecord, warehouseId); + } + + /** + * 上传当前仓库前端独立部署证书(证书/私钥成对,需登录、仅仓库主体)。 + * + * domain 不再作为入参受理:域名一律取库内已设置的值(前端若仍传 domain 会被忽略), + * 且必须先通过 DNS TXT 验证(domain_status=1)才允许上传。 + * 校验链:库内域名非空且已验证 → 证书可解析 → 未生效拒绝 → 已过期拒绝 → + * 私钥与证书成对 → 证书 SAN/CN 覆盖库内 domain(支持 *.example.com 通配,不覆盖返回 400)。 + * 证书校验链任一失败均返回统一文案“证书不合法”(400),不返回细节。 + * 通过后自动写入 cert_expire_at(证书 validTo 权威值,不接受前端传值), + * 证书/私钥 PEM 内容直接写入 cert_pem/cert_key 列(内容仅定时任务读取,不写暂存文件); + * cert_path/key_path 保存时置空,避免内容已换而路径陈旧,等待定时任务部署后回填真实路径; + * 同时重置同步状态;写库成功后清理该域名的公共拉取缓存(先写库后清缓存)。 + * + * @param {Object} [data={}] 请求参数。 + * @param {string} data.pem 证书 PEM 文本(必填)。 + * @param {string} data.key 私钥 PEM 文本(必填,与证书成对)。 + * @return {Promise} 保存后的证书输出对象(13 字段,含证书/私钥原文回显)。 + * @throws {Error} 非仓库主体时抛出 403;未设置/未验证域名、参数非法或证书不合法时抛出 400。 + */ + async saveCert(data = {}) { + const warehouseId = this.getCurrentWarehouseId(); + + // 仅仓库主体管理员可上传前端独立部署证书(isWarehouse 判定) + await this.assertWarehouseSubject(); + + const configModel = this.ctx.model && this.ctx.model.WarehouseFrontConfig; + if (!configModel || typeof configModel.findOne !== 'function') { + throw this.createError('WarehouseFrontConfig model 不可用', 500); + } + + // 入参必填校验:pem/key 必填(nginx 起 HTTPS 需要成对);data.domain 一律忽略不受理 + const certPem = this.normalizePem(data.pem, 'pem'); + if (!certPem) { + throw this.createError('pem 不能为空', 400); + } + + const keyPem = this.normalizePem(data.key, 'key'); + if (!keyPem) { + throw this.createError('key 不能为空', 400); + } + + const record = await configModel.findOne({ + where: { + store_id: warehouseId, + }, + }); + + // 前置闸门:证书必须挂在当前仓库已设置并验证通过的域名上 + const domain = record ? String(record.get('domain') || '').trim() : ''; + if (!domain) { + throw this.createError('请先设置并验证域名', 400); + } + + if (Number(record.get('domain_status') || 0) !== DOMAIN_STATUS_VERIFIED) { + throw this.createError('域名未通过验证,暂时无法上传证书', 400); + } + + // 校验链:证书可解析 → 未生效/已过期拒绝 → 私钥匹配 → SAN/CN 覆盖库内域名 + const cert = this.parseCertPem(certPem); + this.assertCertValid(cert); + this.validateKeyPem(keyPem, cert); + + const certNames = this.collectCertNames(cert); + if (!this.certCoversDomain(certNames, domain)) { + throw this.createError('证书不合法', 400); + } + + // 证书/私钥内容直接入库(不再写暂存文件),有效期以证书 validTo 权威写入。 + // cert_path/key_path 保存时置空:内容已换而路径陈旧,避免 nginx 误读; + // 等待定时任务(Egg schedule/外部 crontab)部署后回填真实路径。 + // patch 内不再含 domain:本接口已不受理域名变更,域名唯一性由 setDomain 保证,无需重复校验。 + const patch = { + cert_pem: certPem, + cert_key: keyPem, + cert_path: null, + key_path: null, + cert_expire_at: new Date(cert.validTo), + // 保存即重置同步状态:本次上传待同步 + sync_status: 0, + sync_attempts: 0, + last_sync_error: null, + last_synced_at: null, + }; + + try { + await record.update(patch); + } catch (error) { + // 并发写入兜底:唯一索引冲突统一转为业务错误 + if (error && error.name === 'SequelizeUniqueConstraintError') { + throw this.createError('仓库前端配置保存冲突,请稍后重试', 409); + } + throw error; + } + + // 回查一次再输出,避免实例上残留 CURRENT_TIMESTAMP 等字面量 + const savedRecord = await configModel.findByPk(record.id); + + // 写库成功后清理公共拉取缓存(先写库后清缓存:避免先清后写时并发读把旧值重新写回缓存)。 + // 域名已不能在本接口变更,「旧域名/新域名」必然相同,因此只需清当前域名一个 key; + // 清缓存失败仅记日志,不影响保存结果。 + await this.clearDomainCache(domain) + .catch(error => { + this.ctx.logger.warn('[FrontConfigService.saveCert] 清理前端配置缓存失败: %s', error.message); + }); + + return this.buildCertOutput(savedRecord, warehouseId); + } +} + +module.exports = FrontConfigService; diff --git a/config/config.default.js b/config/config.default.js index 9f97075..4c62c3b 100644 --- a/config/config.default.js +++ b/config/config.default.js @@ -311,6 +311,17 @@ module.exports = appInfo => { // 该目录保留供未来定时任务(Egg schedule 或外部 crontab)从库内 cert_pem/cert_key 读取内容后写 nginx 证书目录使用。 config.frontConfig = { certStagingDir: '/data/wms/cert-staging', + // 前端独立部署:域名验证(DNS TXT 校验) + cname: '', // 用户把域名 CNAME 指向的目标(未验证时返回给前端展示) + domainVerify: { + enable: true, // 是否注册域名验证定时任务 + interval: '10m', // 扫描间隔 + lockTtlSeconds: 600, // Redis 跨进程锁 TTL(略大于 interval) + batchSize: 50, // 单轮最多处理行数 + dohUrl: 'https://doh.pub/dns-query', + timeoutMs: 5000, // 单次 DoH 请求超时 + maxAttempts: 20, // 超过后不再自动重试(仍可手动 checkDomain) + }, }; return { diff --git a/database/migrations/20260924120000-add-domain-verify-to-wms-warehouse-front-config.js b/database/migrations/20260924120000-add-domain-verify-to-wms-warehouse-front-config.js new file mode 100644 index 0000000..9550877 --- /dev/null +++ b/database/migrations/20260924120000-add-domain-verify-to-wms-warehouse-front-config.js @@ -0,0 +1,186 @@ +'use strict'; + +const TABLE_NAME = 'wms_warehouse_front_config'; +const DOMAIN_STATUS_COLUMN = 'domain_status'; +const DOMAIN_STATUS_INDEX_NAME = 'idx_domain_status'; + +/** + * Migration: 仓库前端配置表新增域名验证(DNS TXT 校验)相关列与索引。 + * + * 背景: + * 前端独立部署需要用户把自持域名解析到平台,必须校验域名归属,避免非自持域名 + * 被指向平台(域名误配/抢注、证书误签)。方案为 DNS TXT 校验:后端为每个仓库 + * 生成一次性校验主机名(wmsv-<10 位 hex>.<域名>)与校验值(32 位 hex),用户在 + * 该子域配置 TXT 记录,后端解析比对通过后置为已验证。未通过验证的域名不得上传 + * 证书(frontConfig.saveCert 前置闸门),公共按域名拉取同以 domain_status=1 为闸门。 + * + * 新增列: + * - domain_status : 域名验证状态:0-未验证,1-已验证,2-验证失败(NOT NULL,默认 0); + * - domain_verify_host : 待校验 TXT 记录主机名(wmsv-<随机码>.<域名>); + * - domain_verify_token : 待校验 TXT 记录值(32 位 hex); + * - domain_verified_at : 域名验证通过时间; + * - domain_verify_attempts : 验证尝试次数(定时任务自增,超过 maxAttempts 后停止自动重试); + * - domain_last_error : 最近一次验证失败原因(脱敏截断,≤500 字符)。 + * 新增索引: + * - idx_domain_status:域名验证定时任务按 domain_status 扫描待验证行的查询索引。 + * + * ⚠ 存量数据回填(本次迁移的关键动作): + * 升级前已写入 domain 的行,其域名在线上已生效(nginx 已在按域名提供服务),必须 + * 视为「已验证」,否则新加入的 domain_status=1 闸门会在升级瞬间把生产现有域名 + * 全部断掉(证书上传被拒、公共拉取被拒)。 + * 回填 SQL:UPDATE ... SET domain_status = 1 + * WHERE domain IS NOT NULL AND domain <> '' AND domain_status = 0。 + * 回填只在本次真正新增 domain_status 列的那一次执行:迁移允许重复执行,若列已存在 + * 仍继续回填,会把「升级后新设置但尚未验证」的域名误标为已验证。 + * domain_verified_at 保持 NULL:历史生效时间不可考,不写入虚假时间。 + * + * Idempotent: 列/索引已存在时跳过;down 逐索引、逐列判存在后删除。 + */ + +/** + * 判断表是否存在。 + * @param {import('sequelize').QueryInterface} queryInterface 查询接口。 + * @param {string} tableName 表名。 + * @return {Promise} 存在返回 true。 + */ +async function tableExists(queryInterface, tableName) { + const tables = await queryInterface.showAllTables(); + return tables.some(t => (typeof t === 'string' ? t : (t.tableName || t.name)) === tableName); +} + +/** + * 判断索引是否存在。 + * @param {import('sequelize').QueryInterface} queryInterface 查询接口。 + * @param {string} tableName 表名。 + * @param {string} indexName 索引名。 + * @return {Promise} 存在返回 true。 + */ +async function indexExists(queryInterface, tableName, indexName) { + const indexes = await queryInterface.showIndex(tableName); + return (indexes || []).some(item => (typeof item === 'string' ? item : item.name) === indexName); +} + +module.exports = { + /** + * 执行正向迁移:新增域名验证相关列与索引,并回填存量已生效域名(幂等)。 + * @param {import('sequelize').QueryInterface} queryInterface 查询接口。 + * @param {import('sequelize')} Sequelize Sequelize 实例。 + * @return {Promise} 无返回值。 + */ + async up(queryInterface, Sequelize) { + if (!(await tableExists(queryInterface, TABLE_NAME))) { + return; + } + + const columns = await queryInterface.describeTable(TABLE_NAME); + const domainStatusAdded = !columns[DOMAIN_STATUS_COLUMN]; + + if (domainStatusAdded) { + await queryInterface.addColumn(TABLE_NAME, DOMAIN_STATUS_COLUMN, { + type: Sequelize.TINYINT, + allowNull: false, + defaultValue: 0, + comment: '域名验证状态:0-未验证,1-已验证,2-验证失败', + after: 'domain', + }); + } + + if (!columns.domain_verify_host) { + await queryInterface.addColumn(TABLE_NAME, 'domain_verify_host', { + type: Sequelize.STRING(255), + allowNull: true, + comment: '待校验 TXT 记录主机名(wmsv-<随机码>.<域名>)', + after: 'domain_status', + }); + } + + if (!columns.domain_verify_token) { + await queryInterface.addColumn(TABLE_NAME, 'domain_verify_token', { + type: Sequelize.STRING(64), + allowNull: true, + comment: '待校验 TXT 记录值(32 位 hex)', + after: 'domain_verify_host', + }); + } + + if (!columns.domain_verified_at) { + await queryInterface.addColumn(TABLE_NAME, 'domain_verified_at', { + type: Sequelize.DATE, + allowNull: true, + comment: '域名验证通过时间', + after: 'domain_verify_token', + }); + } + + if (!columns.domain_verify_attempts) { + await queryInterface.addColumn(TABLE_NAME, 'domain_verify_attempts', { + type: Sequelize.INTEGER(11), + allowNull: false, + defaultValue: 0, + comment: '域名验证尝试次数', + after: 'domain_verified_at', + }); + } + + if (!columns.domain_last_error) { + await queryInterface.addColumn(TABLE_NAME, 'domain_last_error', { + type: Sequelize.STRING(500), + allowNull: true, + comment: '最近一次域名验证失败原因', + after: 'domain_verify_attempts', + }); + } + + if (!(await indexExists(queryInterface, TABLE_NAME, DOMAIN_STATUS_INDEX_NAME))) { + await queryInterface.addIndex(TABLE_NAME, [ DOMAIN_STATUS_COLUMN ], { + name: DOMAIN_STATUS_INDEX_NAME, + }); + } + + // 存量回填:升级前已写入 domain 的行在线上已生效,必须视为「已验证」, + // 否则 domain_status=1 闸门会在升级瞬间断掉生产现有域名。 + // 仅在本次真正新增该列时执行(重复执行迁移不得把新设置但未验证的域名误标为已验证), + // WHERE 仍带 domain_status = 0 守卫,重复执行同样安全。 + if (domainStatusAdded) { + const [ result ] = await queryInterface.sequelize.query( + `UPDATE \`${TABLE_NAME}\` + SET \`domain_status\` = 1 + WHERE \`domain\` IS NOT NULL + AND \`domain\` <> '' + AND \`domain_status\` = 0` + ); + const affectedRows = Number(result && result.affectedRows !== undefined ? result.affectedRows : result) || 0; + console.log(`[migration] ${TABLE_NAME} 存量域名回填 domain_status=1,影响行数=${affectedRows}`); + } + }, + + /** + * 回滚迁移:删除域名验证相关索引与列(幂等)。 + * 注意:回滚会一并丢弃域名验证状态与校验记录,域名将退回「无验证闸门」状态。 + * @param {import('sequelize').QueryInterface} queryInterface 查询接口。 + * @return {Promise} 无返回值。 + */ + async down(queryInterface) { + if (!(await tableExists(queryInterface, TABLE_NAME))) { + return; + } + + if (await indexExists(queryInterface, TABLE_NAME, DOMAIN_STATUS_INDEX_NAME)) { + await queryInterface.removeIndex(TABLE_NAME, DOMAIN_STATUS_INDEX_NAME); + } + + const columns = await queryInterface.describeTable(TABLE_NAME); + for (const columnName of [ + 'domain_last_error', + 'domain_verify_attempts', + 'domain_verified_at', + 'domain_verify_token', + 'domain_verify_host', + DOMAIN_STATUS_COLUMN, + ]) { + if (columns[columnName]) { + await queryInterface.removeColumn(TABLE_NAME, columnName); + } + } + }, +}; diff --git a/script/deploy-cert-sync.cjs b/script/deploy-cert-sync.cjs index be2d855..5e02f98 100644 --- a/script/deploy-cert-sync.cjs +++ b/script/deploy-cert-sync.cjs @@ -178,10 +178,21 @@ const seq = new Sequelize(client.database, client.username || client.user, clien if (exists) { const [cols] = await seq.query("SELECT column_name AS cn FROM information_schema.columns WHERE table_schema = DATABASE() AND table_name = 'wms_warehouse_front_config'"); console.log("[DB_PROBE] columns: " + cols.map(r => r.cn).join(",")); + const hasDomainStatus = cols.some(r => r.cn === "domain_status"); + console.log("[DB_PROBE] domain_status column: " + (hasDomainStatus ? "YES" : "NO")); const [total] = await seq.query("SELECT COUNT(*) AS c FROM wms_warehouse_front_config"); console.log("[DB_PROBE] total rows: " + total[0].c); const [dist] = await seq.query("SELECT sync_status AS s, COUNT(*) AS c FROM wms_warehouse_front_config GROUP BY sync_status ORDER BY sync_status"); console.log("[DB_PROBE] sync_status distribution: " + (dist.length ? dist.map(r => r.s + "=" + r.c).join(" ") : "(empty)")); + if (hasDomainStatus) { + const [ddist] = await seq.query("SELECT domain_status AS s, COUNT(*) AS c FROM wms_warehouse_front_config GROUP BY domain_status ORDER BY domain_status"); + console.log("[DB_PROBE] domain_status distribution: " + (ddist.length ? ddist.map(r => (r.s === null ? "null" : r.s) + "=" + r.c).join(" ") : "(empty)")); + const sumStatus = want => ddist.filter(r => Number(r.s) === want).reduce((n, r) => n + Number(r.c), 0); + console.log("[DB_PROBE] domain_status counts: 0_unverified=" + sumStatus(0) + " 1_verified=" + sumStatus(1) + " 2_failed=" + sumStatus(2)); + console.log("[DB_PROBE] gated-out rows (domain_status 0/2, no nginx server block after gate): " + (sumStatus(0) + sumStatus(2))); + } else { + console.log("[DB_PROBE] domain_status distribution: (column missing, migration not applied; cert-sync falls back to no filter)"); + } } } catch (e) { console.log("[DB_PROBE] failed: " + e.message); diff --git a/script/warehouse-cert-sync.cjs b/script/warehouse-cert-sync.cjs index 91c48de..71218af 100644 --- a/script/warehouse-cert-sync.cjs +++ b/script/warehouse-cert-sync.cjs @@ -473,16 +473,43 @@ function nginxBinExists(nginxBin, nginxPrefix) { } /** - * 扫描待同步记录(sync_status=0,按 id 升序,limit 条)。 + * 探测 wms_warehouse_front_config 是否已有 domain_status 列。 + * + * 域名验证闸门依赖该列;脚本部署早于迁移时该列不存在,需降级为不按验证状态过滤, + * 保证脚本可在迁移前先行部署(与 app/service/systems/frontConfig.js 的降级策略一致)。 + * @param {import('sequelize').Sequelize} sequelize Sequelize 实例。 + * @return {Promise} 存在返回 true;探测失败返回 false。 + */ +async function hasDomainStatusColumn(sequelize) { + try { + const rows = await sequelize.query( + `SELECT COUNT(*) AS c FROM information_schema.columns + WHERE table_schema = DATABASE() AND table_name = ? AND column_name = 'domain_status'`, + { replacements: [ TABLE_NAME ], type: Sequelize.QueryTypes.SELECT } + ); + return Number(rows && rows[0] && rows[0].c) > 0; + } catch (error) { + console.warn(`[CERT-SYNC] domain_status 列探测失败(按无该列降级): ${sanitizeErrorText(error.message)}`); + return false; + } +} + +/** + * 扫描待同步记录(sync_status=0、且域名已验证 domain_status=1,按 id 升序,limit 条)。 + * + * 域名验证闸门:未通过验证(domain_status 为 0/2)的域名不生成 nginx server 块; + * filterVerifiedDomain 为 false 时(迁移尚未执行、无 domain_status 列)降级为不过滤。 * @param {import('sequelize').Sequelize} sequelize Sequelize 实例。 * @param {number} limit 单次处理条数上限。 + * @param {boolean} [filterVerifiedDomain] 是否只取已验证域名,默认 true。 * @return {Promise} 待同步记录数组。 */ -async function scanPendingRows(sequelize, limit) { +async function scanPendingRows(sequelize, limit, filterVerifiedDomain = true) { + const verifiedFilter = filterVerifiedDomain ? ' AND domain_status = 1' : ''; return sequelize.query( `SELECT id, store_id, domain, cert_pem, cert_key, cert_expire_at, sync_attempts FROM ${TABLE_NAME} - WHERE sync_status = 0 + WHERE sync_status = 0${verifiedFilter} ORDER BY id ASC LIMIT ?`, { replacements: [ limit ], type: Sequelize.QueryTypes.SELECT } @@ -917,7 +944,14 @@ async function main() { } } - const rows = await scanPendingRows(sequelize, args.limit); + // 域名验证闸门:迁移尚未执行(无 domain_status 列)时降级为不按验证状态过滤, + // 保证脚本可先行部署;迁移执行后自动生效 + const domainStatusReady = await hasDomainStatusColumn(sequelize); + if (!domainStatusReady) { + console.warn('[CERT-SYNC] 未检测到 wms_warehouse_front_config.domain_status 列(迁移尚未执行),本轮降级为不按域名验证状态过滤'); + } + + const rows = await scanPendingRows(sequelize, args.limit, domainStatusReady); if (!rows || rows.length === 0) { console.log('[CERT-SYNC] 无待同步记录,静默退出'); return;