'use strict'; const crypto = require('node:crypto'); // 域名验证 TXT 记录的兜底解析使用 Node 内置 DNS(本文件为全仓首次引入 node:dns): // DoH(ctx.curl)多端点全部「未取到值」时降级为系统解析,且显式限时(见 resolveTxtBySystem); // 仅服务域名验证链路,不参与业务主链路。 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,数据库不兜底)。 * * 两阶段切换后「占用」的定义包含待验证域名:其他仓库的 domain 或 pending_domain * 命中任一即视为已占用(否则两个仓库可同时把同一域名登记为待验证,直到「提升」时才在 * domain 唯一索引上撞车)。注意 pending_domain 只有普通索引(非唯一), * 并发提交仍可能绕过本校验,最终由 domain 唯一索引在提升时兜底。 * * @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: { store_id: { [Op.ne]: excludeWarehouseId }, [Op.or]: [ { domain }, { pending_domain: domain }, ], }, attributes: [ 'store_id', 'domain', 'pending_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}:单轮最多处理行数; * - dohUrls {string[]}:DoH 端点数组(顺序即尝试顺序,多端点顺序尝试、命中即返回); * - dohUrl {string}:恒等于 dohUrls[0],兼容仍在读单端点键的旧调用方(历史单字符串配置仍生效); * - timeoutMs {number}:单个 DoH 端点、以及系统 DNS 兜底单次查询的超时(毫秒); * - 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; }; const dohUrls = this.resolveDohUrls(raw); return { enable: raw.enable !== false, interval: String(raw.interval || '10m'), lockTtlSeconds: toPositiveNumber(raw.lockTtlSeconds, 600), // 单轮行数上限:最坏耗时核算见 DEFAULT_DOMAIN_VERIFY_BATCH_SIZE 与 config.default.js 注释 batchSize: Math.floor(toPositiveNumber(raw.batchSize, DEFAULT_DOMAIN_VERIFY_BATCH_SIZE)), // 同时暴露数组与首项:dohUrls 供调用方按序尝试多个端点,dohUrl 兼容旧的单端点读取方(恒为 dohUrls[0]) dohUrls, dohUrl: dohUrls[0], timeoutMs: toPositiveNumber(raw.timeoutMs, DEFAULT_DOH_TIMEOUT_MS), maxAttempts: Math.floor(toPositiveNumber(raw.maxAttempts, 20)), }; } /** * 解析 DoH 端点列表(dohUrl → dohUrls 的兼容规则)。 * * 兼容规则(按优先级): * 1. config.frontConfig.domainVerify.dohUrls 为「有效非空字符串数组」(逐项 trim 后至少一项非空)→ 使用它,顺序不变; * 2. 否则 config.frontConfig.domainVerify.dohUrl 非空(历史单字符串配置)→ 等价于 [dohUrl]; * 3. 否则使用内置默认数组 DEFAULT_DOH_URLS。 * * 数组项若全为空串/空白/非字符串,视为「无效配置」继续走规则 2/3,避免配置写错时整个解析链路不可用。 * * @param {Object} [raw] config.frontConfig.domainVerify 原始配置对象。 * @return {string[]} 去空后的 DoH 端点数组,至少含一项。 */ resolveDohUrls(raw) { const source = raw || {}; const normalizeList = list => (Array.isArray(list) ? list : []) .map(url => String(url === undefined || url === null ? '' : url).trim()) .filter(url => url.length > 0); const multi = normalizeList(source.dohUrls); if (multi.length > 0) { return multi; } const single = normalizeList([ source.dohUrl ]); if (single.length > 0) { return single; } return DEFAULT_DOH_URLS.slice(); } /** * 读取 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 端点解析 TXT 记录,并把结果三分类(本方法自身不抛异常)。 * * 分类口径: * - values:拿到至少一条 TXT 值 → 调用方应立即返回,不再尝试后续端点; * - empty :Status === 0 且有 Question 但无 Answer(NODATA),或 Status === 3(NXDOMAIN) * → 「本端点未解析到记录」。注意这不等于「记录一定不存在」:可能是该端点的负缓存滞后 * (见 resolveTxtByDoh 中的实测案例),故调用方必须继续尝试下一个端点,不能就此定论; * - error :请求异常/超时、HTTP 非 200、响应体非对象等 → 「本端点解析失败」,同样继续下一个端点。 * * @param {string} host 待解析主机名。 * @param {string} endpoint DoH 端点地址(不含查询串)。 * @param {number} timeoutMs 单端点请求超时(毫秒)。 * @return {Promise} { kind: values|empty|error, endpoint: string, values?: string[], reason?: string }。 * reason 已脱敏截断,仅用于日志与最终错误文案。 */ async queryDohEndpoint(host, endpoint, timeoutMs) { try { const url = endpoint + '?name=' + encodeURIComponent(host) + '&type=TXT'; const response = await this.ctx.curl(url, { method: 'GET', headers: { accept: 'application/dns-json' }, timeout: timeoutMs, dataType: 'json', }); const statusCode = Number(response && response.status) || 0; if (statusCode !== 200) { return { kind: 'error', endpoint, reason: 'DoH 服务返回异常状态码 ' + statusCode }; } const body = response && response.data; if (!body || typeof body !== 'object') { return { kind: 'error', endpoint, reason: 'DoH 响应体不是合法 JSON' }; } const values = this.extractTxtValuesFromAnswers(body.Answer); if (values.length > 0) { return { kind: 'values', endpoint, values }; } // Status=3(NXDOMAIN)或 Status=0 但无 Answer(NODATA)→ 端点级「未解析到记录」 return { kind: 'empty', endpoint }; } catch (error) { return { kind: 'error', endpoint, reason: this.sanitizeErrorText(error && error.message) || 'DoH 请求异常', }; } } /** * DoH(DNS-over-HTTPS)多端点顺序解析 TXT 记录。 * * 契约变更(内部 helper,仅本文件 resolveTxtValues 调用): * 旧版返回 string[](单端点 dohUrl,NODATA 直接定论为「无记录」);现返回明细对象, * 以便上层区分「端点说没有记录(empty)」与「端点不可用(error)」并据此决定是否降级系统 DNS。 * 对外契约(resolveTxtValues / verifyDomainRecord)保持向后兼容。 * * 为什么不能让单端点的 NODATA 直接定论(本次线上实测案例): * 主机 wmsv-aa4adaab13.wms.wms.gztbyc.com 的 TXT 记录 ddd9ae51cf95b488db544f23ccd01e7b 真实存在 * (8.8.8.8 / 223.5.5.5 / nslookup / AliDNS DoH 四方一致),但默认端点 https://doh.pub/dns-query * 仍返回 Status=0 且 Answer 为空(陈旧负缓存:同一主机 A 查询同步 NODATA,返回的 SOA 序列号 2026081813 * 旧于 TXT 查询的 2026082815,重复两次结果一致)。旧实现据此直接返回 [] 且不降级, * 导致 verifyDomainRecord 判 verified=false → domain_status 被打成 2 → 被 getByDomain/nginx 闸门断流。 * 因此这里改为:只有端点「明确拿到值」才立即成功返回;某个端点 empty 仅记为「候选无记录」, * 必须等所有端点都尝试完(必要时再降级系统 DNS)才定论。 * * @param {string} host 待解析主机名。 * @param {Object} verifyConfig 域名验证配置(getDomainVerifyConfig 返回值,取 dohUrls / timeoutMs)。 * @return {Promise} { values: string[], endpoint: string|null, hadEmpty: boolean, * emptyEndpoint: string|null, errors: Array<{endpoint: string, reason: string}> }。 * values 非空时 endpoint 为命中端点;values 为空时 emptyEndpoint 为第一个报 empty 的端点(无则 null), * errors 为所有端点级失败原因(已脱敏)。本方法自身不抛异常。 */ async resolveTxtByDoh(host, verifyConfig) { const configured = verifyConfig && verifyConfig.dohUrls; const endpoints = Array.isArray(configured) && configured.length > 0 ? configured : this.resolveDohUrls({}); const configuredTimeout = Number(verifyConfig && verifyConfig.timeoutMs); const timeoutMs = Number.isFinite(configuredTimeout) && configuredTimeout > 0 ? configuredTimeout : DEFAULT_DOH_TIMEOUT_MS; const errors = []; let emptyEndpoint = null; for (const endpoint of endpoints) { const result = await this.queryDohEndpoint(host, endpoint, timeoutMs); if (result.kind === 'values') { return { values: result.values, endpoint: result.endpoint, hadEmpty: !!emptyEndpoint, emptyEndpoint, errors, }; } if (result.kind === 'empty') { if (!emptyEndpoint) { emptyEndpoint = result.endpoint; } this.ctx.logger.info( '[FrontConfigService.resolveTxtByDoh] 端点返回 NODATA/NXDOMAIN,继续尝试下一个端点: host=%s endpoint=%s', host, result.endpoint ); continue; } errors.push({ endpoint: result.endpoint, reason: result.reason }); this.ctx.logger.warn( '[FrontConfigService.resolveTxtByDoh] 端点解析失败,继续尝试下一个端点: host=%s endpoint=%s reason=%s', host, result.endpoint, result.reason ); } return { values: [], endpoint: null, hadEmpty: !!emptyEndpoint, emptyEndpoint, errors }; } /** * 系统 DNS(node:dns)解析 TXT 记录:DoH 全部端点都未取到值后的兜底路径。 * * 特别注意(本次实测):本机 Node resolver 可能指向不可用的解析器(Windows 上出现 127.0.0.1, * 而实际 DNS 为 192.168.8.1,该解析器对 TXT 查询直接超时),此时 resolveTxt 报 ECONNREFUSED/超时。 * c-ares 自身默认「5s × 多次重试」,故这里显式限时,避免单行串行阻塞定时任务整轮(核算见 resolveTxtValues)。 * * @param {string} host 待解析主机名。 * @param {number} [timeoutMs] 超时上限(毫秒);≤ 0 或未传时不做限时(保持旧行为)。 * @return {Promise} TXT 记录文本列表(多段已拼接、去空、截断)。 * @throws {Error} 解析失败(含 NXDOMAIN/超时)时抛出。 */ async resolveTxtBySystem(host, timeoutMs) { const limitMs = Number(timeoutMs) > 0 ? Number(timeoutMs) : 0; const query = (async () => { 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; })(); if (limitMs <= 0) { return query; } let timer = null; try { // Promise.race 会给两个分支都挂上处理器,落败分支的 reject 不会产生 unhandledRejection return await Promise.race([ query, new Promise((_resolve, reject) => { timer = setTimeout( () => reject(new Error('系统 DNS 解析超时(>' + limitMs + 'ms)')), limitMs ); }), ]); } finally { if (timer) { clearTimeout(timer); } } } /** * 解析指定主机名的 TXT 记录(DoH 多端点顺序尝试为主,必要时降级系统 DNS)。 * * 决策流程: * 1. 依次尝试 dohUrls(见 getDomainVerifyConfig / resolveDohUrls)中的每个端点: * - 有 TXT 值 → 立即返回 { values, source: 'doh', endpoint }; * - empty(Status=0 且无 Answer / Status=3 NXDOMAIN)→ 记下「候选无记录」并继续下一个端点; * - error(异常/超时/HTTP 非 200/响应体非对象)→ 记录脱敏原因并继续下一个端点。 * 2. 所有端点结束后: * - 至少一个端点 empty(且无端点拿到值)→ 降级系统 DNS: * · 有值 → { values, source: 'system', endpoint: null }; * · 空/NXDOMAIN → { values: [], source: 'doh', endpoint: null }(语义=未解析到记录,不抛错); * · 抛错(如 ECONNREFUSED)→ 仍按「未解析到记录」返回 []:已有端点明确说没有该记录时, * 不能因为兜底路径不可用就把结果升级成 500(否则会把「没配记录」误报成服务故障)。 * - 所有端点都是 error(无任何 empty)→ 降级系统 DNS: * · 有值 → { values, source: 'system', endpoint: null }; * · 空 → { values: [], source: 'system', endpoint: null }(系统 DNS 明确答复为空 → 未解析到记录); * · 抛错 → 所有可用解析路径都不可用 → 抛 500(保持旧语义 + 脱敏/截断)。 * * 兼容性:返回对象在既有 { values, source } 之上「追加」 endpoint 字段; * verifyDomainRecord / checkDomain / verifyPendingDomains / app/schedule 的签名与判定口径均不变, * verifyDomainRecord 仍永不抛异常(解析失败只体现为 error 文案)。 * * 可观测性:端点级失败、降级决策与最终定论都会打 INFO/WARN 日志并带上 source/endpoint, * 便于把「记录确实不存在」与「解析链路整体不可用」区分开。 * * 最坏耗时:单主机 ≈ (DoH 端点数 3 + 系统 DNS 兜底 1) × timeoutMs(3000ms) = 12s(系统 DNS 亦按 timeoutMs 限时); * 单轮 batchSize(20) 行最坏 ≈ 240s,明显小于 lockTtlSeconds(600s) 与 interval(600s)。 * * @param {string} host 待解析主机名(域名验证一律传 domain_verify_host,不用裸域名)。 * @return {Promise} { values: string[], source: 'doh'|'system', endpoint: string|null }。 * @throws {Error} 所有 DoH 端点均失败且系统 DNS 也失败时抛出,状态码 500,文案已脱敏截断。 */ async resolveTxtValues(host) { const normalizedHost = String(host || '').trim().toLowerCase(); if (!normalizedHost) { throw this.createError('域名解析主机名不能为空', 400); } const verifyConfig = this.getDomainVerifyConfig(); const dohResult = await this.resolveTxtByDoh(normalizedHost, verifyConfig); if (dohResult.values.length > 0) { return { values: dohResult.values, source: 'doh', endpoint: dohResult.endpoint }; } // 至少一个端点明确「未解析到记录」(NODATA/NXDOMAIN)→ 已有旁证,系统 DNS 仅作二次确认 const trustedEmpty = dohResult.hadEmpty; let systemValues = null; let systemError = null; try { systemValues = await this.resolveTxtBySystem(normalizedHost, verifyConfig.timeoutMs); } catch (error) { systemError = error; } if (Array.isArray(systemValues) && systemValues.length > 0) { this.ctx.logger.info( '[FrontConfigService.resolveTxtValues] DoH 未取到值,系统 DNS 命中: host=%s dohEmptyEndpoint=%s', normalizedHost, dohResult.emptyEndpoint || '-' ); return { values: systemValues, source: 'system', endpoint: null }; } if (trustedEmpty) { if (systemError) { this.ctx.logger.warn( '[FrontConfigService.resolveTxtValues] DoH 有端点明确无记录、系统 DNS 失败,按「未解析到记录」处理: host=%s endpoint=%s reason=%s', normalizedHost, dohResult.emptyEndpoint, this.sanitizeErrorText(systemError.message) || '未知错误' ); } return { values: [], source: 'doh', endpoint: null }; } if (!systemError) { // 所有 DoH 端点均 error,但系统 DNS 明确答复为空 → 未解析到记录(不升级为 500) this.ctx.logger.warn( '[FrontConfigService.resolveTxtValues] DoH 端点全部失败且系统 DNS 返回空,按「未解析到记录」处理: host=%s dohErrors=%d', normalizedHost, dohResult.errors.length ); return { values: [], source: 'system', endpoint: null }; } const systemReason = this.sanitizeErrorText(systemError.message) || '未知错误'; const dohReason = dohResult.errors.length > 0 ? dohResult.errors.map(item => item.endpoint + ': ' + item.reason).join('; ') : ''; this.ctx.logger.warn( '[FrontConfigService.resolveTxtValues] DoH 与系统 DNS 均失败: host=%s doh=%s system=%s', normalizedHost, this.sanitizeErrorText(dohReason), systemReason ); throw this.createError( 'DNS 解析失败:' + this.sanitizeErrorText(dohReason ? dohReason + ';系统 DNS: ' + systemReason : systemReason), 500 ); } /** * 校验一条 TXT 归属记录(定时任务逐行调用,必须失败隔离、不得抛异常)。 * * 签名说明(两阶段切换改造):新增可选第二参数 overrides,允许调用方直接指定待校验的 * host / token——校验「待验证域名」时传 pending_verify_host / pending_verify_token * 走这条路径;不传时回退读取记录上的 domain_verify_host / domain_verify_token, * 因此既有两个调用点(生效域名校验 / 升级前逻辑)行为完全不变。 * * @param {Object} record 配置记录(Sequelize 实例或 raw 普通对象;未传 overrides 时需含 domain_verify_host / domain_verify_token)。 * @param {Object} [overrides={}] 显式指定的校验目标。 * @param {string} [overrides.host] 待解析主机名(优先级高于记录上的 domain_verify_host)。 * @param {string} [overrides.token] 待比对 TXT 值(优先级高于记录上的 domain_verify_token)。 * @return {Promise} 校验结果,字段如下: * - verified {boolean}:是否校验通过(解析到的 TXT 记录中包含校验值); * - values {string[]}:实际解析到的 TXT 值; * - source {string}:解析来源 doh/system,未解析为空串(resolveTxtValues 另返回 endpoint,本方法不透出); * - 注意:解析路径「明确无记录」时本方法返回 verified=false + values=[](不抛异常), * 仅当所有 DoH 端点与系统 DNS 都解析失败时,resolveTxtValues 才抛 500 并在此转为 error 文案。 * - error {string|null}:失败原因(已脱敏截断),成功为 null。 */ async verifyDomainRecord(record, overrides = {}) { const overrideHost = String((overrides && overrides.host) || '').trim(); const overrideToken = String((overrides && overrides.token) || '').trim(); const verifyHost = overrideHost || String(this.getRecordField(record, 'domain_verify_host') || '').trim(); const verifyToken = overrideToken || 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, }, }); } } /** * 扫描并校验「待验证域名」(供定时任务与手动触发复用)。 * * 两阶段切换后本方法只处理 pending 组:选取 pending_domain / pending_verify_host / * pending_verify_token 均非空、且 pending_verify_attempts 未达 maxAttempts 上限的行, * 按 id 升序单批处理 batchSize 行。 * · 校验通过 → promotePendingDomain 提升为生效域名(清证书/重置同步/旧域名入下线队列) * + 清旧、新两个域名缓存,计入 verified; * · 校验失败 → pending_verify_attempts + 1、pending_last_error(脱敏截断),计入 failed, * 生效域名、domain_status 与证书一律不动(旧域名不会被本任务断流); * · 已达上限的行不再自动重试,计入 skipped(仍可由 checkDomain 手动触发)。 * * 失败隔离:单行解析/提升/落库失败只计入 errors,不中断整轮;onRow 回调抛错同样不影响主流程。 * fail-soft:model 不可用、或迁移尚未执行(pending_* 列不存在,ER_BAD_FIELD_ERROR) * 时不抛出,返回零统计 + 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, pending_domain, verified_domain, verified, error } * (domain 为库内生效域名,可为空;pending_domain / verified_domain 为本轮校验的待验证域名)。 * @return {Promise<{scanned:number, verified:number, failed:number, skipped:number, errors:string[]}>} * scanned:本轮选中的待处理行数;verified:其中校验通过且提升成功的行数; * failed:校验失败且 pending 状态回写成功的行数;skipped:因达到 maxAttempts 上限而未自动重试的行数; * errors:脱敏后的错误原因列表(含提升失败,这类行不计入 verified / failed)。 */ 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 = { pending_domain: { [Op.ne]: null }, pending_verify_host: { [Op.ne]: null }, pending_verify_token: { [Op.ne]: null }, }; let rows = []; try { rows = await configModel.findAll({ where: { ...pendingWhere, pending_verify_attempts: { [Op.lt]: maxAttempts }, }, attributes: [ 'id', 'store_id', 'domain', 'pending_domain', 'pending_verify_host', 'pending_verify_token', 'pending_verify_attempts', 'pending_last_error', ], order: [[ 'id', 'ASC' ]], limit: batchSize, raw: true, }); } catch (error) { const reason = this.sanitizeErrorText(error.message) || '未知错误'; // 迁移未执行时 pending_* 列不存在:明确提示,避免把「列不存在」误判为数据/网络问题 const hint = this.isUnknownColumnError(error) ? '(迁移 20260924180000-add-pending-domain-to-wms-warehouse-front-config 尚未执行,pending_* 列不存在)' : ''; this.ctx.logger.warn('[FrontConfigService.verifyPendingDomains] 查询待验证域名失败: %s', reason); summary.errors.push('查询待验证域名失败:' + reason + hint); return summary; } // 已达上限的行不再自动重试,单独计数便于观察「自动重试已耗尽」的域名规模; // 计数失败不影响主流程(计入 errors 即可) try { summary.skipped = await configModel.count({ where: { ...pendingWhere, pending_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 pendingDomain = String(row.pending_domain || '').trim(); let result = { verified: false, error: '未解析到 TXT 记录' }; try { // verifyDomainRecord 契约上不抛异常,此处为最后一道兜底,保证单行失败不中断整轮 result = await this.verifyDomainRecord(row, { host: row.pending_verify_host, token: row.pending_verify_token, }); } catch (error) { result = { verified: false, error: this.sanitizeErrorText(error.message) || '域名校验异常' }; } if (result.verified) { // 校验通过 → 提升为生效域名:清空证书、重置同步状态、旧域名写入 retired_domain 下线队列 try { await this.promotePendingDomain(row); summary.verified += 1; // 先写库、后清缓存:旧域名(即将下线)与新域名两个 key 都必须清,清失败仅记 WARN await this.clearDomainCaches( [ rowDomain, pendingDomain ], 'FrontConfigService.verifyPendingDomains' ); } 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 ); } } else { // 校验失败只写 pending 组:生效域名、domain_status 与证书一律不动 const pendingError = this.sanitizeErrorText(result.error || '未解析到 TXT 记录'); try { // 防并发守卫:仅更新 id 与 pending_domain 均匹配的行,避免与并发校验/取消待切换互相覆盖 await configModel.update({ pending_verify_attempts: Number(row.pending_verify_attempts || 0) + 1, pending_last_error: pendingError, }, { where: { id: rowId, pending_domain: row.pending_domain }, }); 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, pending_domain: pendingDomain, verified_domain: pendingDomain, 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 绑定仓库上下文,只能查到自己仓库的配置);无记录时返回空值默认。 * * 两阶段切换后输出在既有 9 个字段之后追加待验证域名组(pending_domain / pending_verify_host / * pending_verify_value / pending_attempts / pending_last_error / pending_created_at / * pending_active),既有字段一律不改名、不删除;字段口径详见 buildDomainOutput。 * * @return {Promise} 域名输出对象,既有 9 字段(warehouse_id/domain/domain_status/ * verify_host/verify_value/cname/verified_at/attempts/last_error)+ 待验证域名组 7 字段 * (pending_domain/pending_verify_host/pending_verify_value/pending_attempts/pending_last_error/ * pending_created_at/pending_active),字段含义见 buildDomainOutput。 * @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); } /** * 设置当前仓库自持域名(需登录、仅仓库主体)。 * * 两阶段切换(本次改造核心):本接口只登记「待验证域名」,不直接改动生效域名。 * 第一阶段(本接口):把入参写入 pending_domain 并下发一次性 DNS TXT 校验记录; * 第二阶段(checkDomain 手动触发 / app/schedule/domain_verify_scan.js 定时扫描): * TXT 校验通过后由 promotePendingDomain 一次性把 pending_domain 提升为 domain * (同时把旧域名写入 retired_domain 下线队列、清空证书并重置同步状态)。 * 这样生效域名全程不变:切换期间旧域名的前端页面与 getByDomain 公共拉取都仍然可用, * 直到提升完成后由外部证书脚本按 retired_domain 删除旧域名的 nginx 配置与证书文件。 * * 分支(域名比较一律忽略大小写): * A) 入参 == 生效域名 domain 且无待验证域名 → 幂等短路:不写库;仅当库内字面值与归一化 * 结果不一致时把 domain 改写为小写并清理新旧两个字面值的缓存 key。 * · 与旧实现的差异:原有「未验证/验证失败且缺校验码则补发校验码」的子分支已移除, * 缺码的历史脏数据行不再自动补码(需重新生效请提交一个不同的待验证域名)。 * B) 入参 == 生效域名 domain 且有 pending_domain → 取消待切换:清空 pending 6 列; * 生效域名、证书 5 列、同步 4 列与公共缓存一律不动。 * C) 入参 == 现有 pending_domain → 校验码齐全则幂等短路(不重发、不写库); * 校验码缺失(脏数据)则只补发 pending 校验码并清 pending 尝试次数/失败原因。 * D) 其它(新的待切换域名,含首次设置)→ 查重(其他仓库的 domain 或 pending_domain * 占用即 409)→ 生成新校验码写入 pending 组;生效域名 domain / domain_status / * domain_verified_at / domain_verify_* / 证书 5 列 / 同步 4 列一律不动, * 也不清理任何公共缓存(新域名尚未生效,getByDomain 不受影响)。 * * @param {Object} [data={}] 请求参数。 * @param {string} data.domain 仓库自持域名(必填,非空,≤100 字符,全局唯一,忽略大小写去重)。 * @return {Promise} 域名输出对象(生效域名组 + 待验证域名组 + 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); } const record = await configModel.findOne({ where: { store_id: warehouseId, }, }); const currentDomain = record ? String(record.get('domain') || '').trim() : ''; const currentPendingDomain = record ? String(record.get('pending_domain') || '').trim() : ''; const matchesCurrentDomain = !!currentDomain && currentDomain.toLowerCase() === normalizedDomain; const matchesPendingDomain = !!currentPendingDomain && currentPendingDomain.toLowerCase() === normalizedDomain; // ===== 分支 A:入参 == 生效域名 且无待验证域名 → 幂等短路(仅大小写规范化时写库) ===== // 本分支刻意跳过 assertDomainUnique 查重:域名已是本仓自身持有,查重恒为「不冲突」, // 属无意义查询;全局唯一性由分支 D 的查重与数据库唯一索引共同兜底。 if (record && matchesCurrentDomain && !currentPendingDomain) { if (currentDomain === normalizedDomain) { // 完全无变化:不写库、不清缓存,直接回显当前状态(幂等) return this.buildDomainOutput(record, warehouseId); } // 大小写规范化:只把 domain 一个字面值字段改写为小写,其余字段一律不动 try { await record.update({ domain: normalizedDomain }); } catch (error) { // 并发写入兜底:唯一索引冲突统一转为业务错误 // (大小写规范化可能撞上其他仓库已占用的同名字面值,属真实冲突) if (error && error.name === 'SequelizeUniqueConstraintError') { throw this.createError(`域名 ${normalizedDomain} 已被其他仓库使用`, 409); } throw error; } // 回查一次再输出,避免实例上残留 CURRENT_TIMESTAMP 等字面量 const refreshedRecord = await configModel.findByPk(record.id); // 缓存清理:公共拉取缓存键按域名字面值精确匹配(front:config:domain:Shop.com 与 // ...:shop.com 是两个 key),新旧两个字面值都必须清 await this.clearDomainCaches( [ currentDomain, normalizedDomain ], 'FrontConfigService.setDomain' ); return this.buildDomainOutput(refreshedRecord, warehouseId); } // ===== 分支 B:入参 == 生效域名 且有待验证域名 → 取消待切换 ===== if (record && matchesCurrentDomain && currentPendingDomain) { // 只清 pending 6 列:生效域名、证书 5 列、同步 4 列一律不动; // 待验证域名从未生效(不参与 getByDomain),因此无需清理公共缓存 await record.update(this.buildPendingClearPatch()); const refreshedRecord = await configModel.findByPk(record.id); return this.buildDomainOutput(refreshedRecord, warehouseId); } // ===== 分支 C:入参 == 现有待验证域名 → 码齐幂等短路,码缺只补码 ===== if (record && matchesPendingDomain) { const pendingVerifyHost = String(record.get('pending_verify_host') || '').trim(); const pendingVerifyToken = String(record.get('pending_verify_token') || '').trim(); if (pendingVerifyHost && pendingVerifyToken) { // 校验码齐全:不重发、不写库,直接回显(幂等) return this.buildDomainOutput(record, warehouseId); } // 脏数据(待验证域名没有校验码)→ 只补发校验码并清 pending 尝试次数/失败原因, // 不碰生效域名、证书与同步状态,也不清缓存(待验证域名未生效) const verifyCode = this.buildDomainVerifyCode(normalizedDomain); await record.update({ pending_domain: normalizedDomain, pending_verify_host: verifyCode.host, pending_verify_token: verifyCode.token, pending_verify_attempts: 0, pending_last_error: null, pending_created_at: record.get('pending_created_at') || new Date(), }); const refreshedRecord = await configModel.findByPk(record.id); return this.buildDomainOutput(refreshedRecord, warehouseId); } // ===== 分支 D:新的待验证域名(含首次设置)→ 只登记 pending,不动生效域名 ===== // domain 全局唯一:可空列唯一索引不拦多个 NULL,非空值的唯一性必须应用层校验 // (其他仓库的 domain 或 pending_domain 命中任一都算占用) await this.assertDomainUnique(normalizedDomain, warehouseId); // 生成校验码并只写入 pending 组;生效域名组/证书/同步状态一律不动 const verifyCode = this.buildDomainVerifyCode(normalizedDomain); const pendingPatch = { pending_domain: normalizedDomain, pending_verify_host: verifyCode.host, pending_verify_token: verifyCode.token, pending_verify_attempts: 0, pending_last_error: null, pending_created_at: new Date(), }; let savedRecord = record; try { if (record) { await record.update(pendingPatch); } else { // 首次设置:新行只带 store_id 与 pending 组;domain 保持 NULL(尚未生效), // domain_status 默认 0,证书脚本只处理 domain_status = 1 的行,不会误处理本行 savedRecord = await configModel.create({ store_id: warehouseId, ...pendingPatch, }); } } 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 未变),getByDomain 结果不受影响 return this.buildDomainOutput(refreshedRecord, warehouseId); } /** * 把「待验证域名」提升为「生效域名」(两阶段切换的第二阶段,checkDomain 与定时扫描共用)。 * * 调用前提:pending_verify_host / pending_verify_token 已经 TXT 校验通过(本方法不再解析 DNS)。 * 一次 update 提交以下字段(where 带 id + pending_domain 守卫,防并发重复提升): * 1. 下线队列:生效域名非空且与待验证域名不同(忽略大小写)→ retired_domain = 旧域名、 * retired_at = now。首次设置(无生效域名)不写这两列(保持 NULL,等价于清空); * 同时刻意不把 retired_domain 置 NULL——队列里可能还有更早的旧域名等待外部证书脚本 * 消费,覆盖会丢失下线任务(孤儿由脚本兜底清理)。 * 2. 生效组:domain = pending_domain、domain_status = 1、domain_verified_at = now、 * domain_verify_host / domain_verify_token / domain_verify_attempts 由 pending_* 平移、 * domain_last_error = null。 * 3. 清空 pending 6 列(pending_verify_attempts 归 0,其余置 NULL)。 * 4. 清空证书 5 列 + 重置同步 4 列:域名已变,旧证书 SAN/CN 不覆盖新域名,必须重新上传; * sync_status = 0 让外部证书脚本在用户上传新证书后自动部署。注意提升后到新证书上传前, * 证书脚本会以「cert_pem 内容为空」记一次同步失败(属预期噪音,失败只落库不删旧域名文件)。 * * 边界:retired_domain 只保留最近一个旧域名,多次连续切换会丢中间域名(由脚本孤儿兜底清理); * 本方法不碰 nginx 文件,也不清缓存——缓存清理由调用方负责(清旧域名与新域名两个 key)。 * * @param {Object} record 配置记录(Sequelize 实例或 raw 普通对象,需含 id 与 pending_* 字段)。 * @return {Promise} 提升后的最新记录实例(findByPk 回查);model 不支持 findByPk 时返回 null。 * @throws {Error} 数据库异常原样抛出(含 domain 唯一索引冲突 SequelizeUniqueConstraintError)。 */ async promotePendingDomain(record) { const configModel = this.ctx.model && this.ctx.model.WarehouseFrontConfig; if (!configModel || typeof configModel.update !== 'function') { throw this.createError('WarehouseFrontConfig model 不可用', 500); } const recordId = Number(this.getRecordField(record, 'id')); const pendingDomain = String(this.getRecordField(record, 'pending_domain') || '').trim(); if (!Number.isFinite(recordId) || recordId <= 0 || !pendingDomain) { throw this.createError('待验证域名记录不完整,无法提升为生效域名', 500); } const previousDomain = String(this.getRecordField(record, 'domain') || '').trim(); const shouldRetire = !!previousDomain && previousDomain.toLowerCase() !== pendingDomain.toLowerCase(); const now = new Date(); const updateValues = { // 生效组:由 pending 组平移 domain: pendingDomain, domain_status: DOMAIN_STATUS_VERIFIED, domain_verified_at: now, domain_verify_host: this.getRecordField(record, 'pending_verify_host') || null, domain_verify_token: this.getRecordField(record, 'pending_verify_token') || null, domain_verify_attempts: Number(this.getRecordField(record, 'pending_verify_attempts') || 0), domain_last_error: null, // 待验证组:清空 ...this.buildPendingClearPatch(), // 证书与同步状态:域名已变,证书必须重新上传(等外部脚本按新域名重新部署) 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, }; if (shouldRetire) { updateValues.retired_domain = previousDomain; updateValues.retired_at = now; } // 防并发守卫:仅更新 id 与 pending_domain 均匹配的行 // (重复提升、用户已取消待切换、其他实例已提升过时都不会误改) await configModel.update(updateValues, { where: { id: recordId, pending_domain: pendingDomain }, }); if (typeof configModel.findByPk === 'function') { return configModel.findByPk(recordId); } return null; } /** * 校验「待验证域名」的 TXT 记录,通过则提升为生效域名(checkDomain 的路径一)。 * * 与旧口径的关键差异:校验失败**只写 pending 组**(pending_verify_attempts / pending_last_error), * 生效域名 domain、domain_status、domain_verified_at 与证书一律不动——旧域名不会被本路径断流。 * * @param {Object} record 配置记录实例(含 pending_* 字段)。 * @param {string} pendingDomain 待验证域名(已 trim,非空)。 * @param {number} warehouseId 当前仓库 ID。 * @return {Promise} 域名输出对象 + verified(本次是否通过)+ resolved_values。 * @throws {Error} 提升时待验证域名已被其他仓库用为生效域名,抛出 409。 */ async checkPendingDomainRecord(record, pendingDomain, warehouseId) { const configModel = this.ctx.model.WarehouseFrontConfig; const previousDomain = String(record.get('domain') || '').trim(); const verifyResult = await this.verifyDomainRecord(record, { host: record.get('pending_verify_host'), token: record.get('pending_verify_token'), }); if (!verifyResult.verified) { // 校验不通过:只写 pending 组;写入失败也不影响结论(回显时按库内值兜底) const pendingError = this.sanitizeErrorText(verifyResult.error) || '未解析到 TXT 记录'; try { await configModel.update({ pending_verify_attempts: Number(record.get('pending_verify_attempts') || 0) + 1, pending_last_error: pendingError, }, { where: { id: record.id, pending_domain: pendingDomain }, }); } catch (error) { this.ctx.logger.warn( '[FrontConfigService.checkPendingDomainRecord] 回写待验证失败原因失败: %s', this.sanitizeErrorText(error.message) ); } const refreshedRecord = await configModel.findByPk(record.id); return { ...this.buildDomainOutput(refreshedRecord || record, warehouseId), verified: false, resolved_values: this.buildResolvedValues(verifyResult.values), }; } // 校验通过 → 提升为生效域名(清证书、重置同步状态、旧域名入下线队列) try { await this.promotePendingDomain(record); } catch (error) { this.ctx.logger.warn( '[FrontConfigService.checkPendingDomainRecord] 提升待验证域名失败 domain=%s: %s', pendingDomain, this.sanitizeErrorText(error.message) ); if (error && error.name === 'SequelizeUniqueConstraintError') { throw this.createError(`域名 ${pendingDomain} 已被其他仓库使用`, 409); } throw error; } // 先写库、后清缓存:旧域名(即将下线)与新域名两个 key 都必须清,清失败仅记 WARN await this.clearDomainCaches( [ previousDomain, pendingDomain ], 'FrontConfigService.checkPendingDomainRecord' ); const promotedRecord = await configModel.findByPk(record.id); return { ...this.buildDomainOutput(promotedRecord || record, warehouseId), verified: true, resolved_values: this.buildResolvedValues(verifyResult.values), }; } /** * 主动执行一次域名 TXT 校验并回写结果(需登录、仅仓库主体)。 * * 两阶段切换后本接口同时承担两条路径: * 1. 存在 pending_domain(切换中)→ 校验 pending_verify_host 的 TXT 是否等于 * pending_verify_token:通过则由 promotePendingDomain 提升为生效域名并清旧/新域名缓存, * 返回 verified = true;不通过只累加 pending_verify_attempts 并记 pending_last_error, * 返回 verified = false。全程不会改动生效域名与证书。 * 2. 无 pending_domain(切换完成或尚未发起切换)→ 保持升级前口径: * · 生效域名已验证(domain_status = 1)→ 一律短路 verified = true,不写库、不加 attempts * (不论库内有无校验码),避免误点「校验」把已生效域名打成验证失败; * · 生效域名为空 → 400「请先设置域名」; * · 生效域名非空但未验证/验证失败(升级前登记的历史行)→ 用生效域名的 domain_verify_* * 校验并回写 domain_status / domain_verify_attempts / domain_last_error(兼容路径)。 * * 校验一律以库内一次性随机子域为目标(不用裸域名),避免与用户主域其它 TXT 记录冲突。 * * @return {Promise} 域名输出对象 + verified(本次是否通过) * + resolved_values(本次解析到的 TXT 值,最多 5 条)。 * @throws {Error} 未识别到当前仓库时抛出 400;未设置域名时抛出 400;非仓库主体时抛出 403; * 待验证域名已被其他仓库用为生效域名时抛出 409。 */ 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, }, }); if (!record) { throw this.createError('请先设置域名', 400); } const pendingDomain = String(record.get('pending_domain') || '').trim(); // ===== 路径一:存在待验证域名 → 校验 pending 的 TXT 记录(通过即提升为生效域名) ===== if (pendingDomain) { return this.checkPendingDomainRecord(record, pendingDomain, warehouseId); } // ===== 路径二:无待验证域名 → 生效域名的校验口径(升级前行为,兼容历史行) ===== const domain = String(record.get('domain') || '').trim(); if (!domain) { throw this.createError('请先设置域名', 400); } const domainStatus = Number(record.get('domain_status') || 0); // 已验证域名一律短路(不论库内有无校验码): // 1) 兼容迁移回填的历史行:域名线上已生效(直接视为已验证)但从未生成校验记录; // 2) 已验证域名不需要重复校验;若不短路,用户误点一次「校验」会走真实 DNS 解析, // 失败即写 domain_status = 2 且 attempts + 1,把已生效域名降级后被 getByDomain 与 // nginx 闸门断流; // 3) 短路不写库、不降状态、不加 attempts,返回结构与 getDomain 口径一致。 if (domainStatus === DOMAIN_STATUS_VERIFIED) { return { ...this.buildDomainOutput(record, warehouseId), verified: true, resolved_values: [], }; } const patch = {}; let verifyHost = String(record.get('domain_verify_host') || '').trim(); let verifyToken = String(record.get('domain_verify_token') || '').trim(); // 未验证/验证失败(domain_status ∈ {0, 2},已验证行已在上方短路)且库内缺少校验码: // 补发一份,用户配置 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(record, { host: verifyHost, 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: this.buildResolvedValues(verifyResult.values), }; } /** * 构建域名验证输出对象(getDomain/setDomain/checkDomain 共用)。 * * 返回结构(两阶段切换后扩展,既有字段一律不改名、不删除): * · 生效域名组:warehouse_id / domain / domain_status / verify_host / verify_value / * verified_at / attempts / last_error;domain_status = 1(已验证)时 verify_host / * verify_value 返回空串(校验令牌已无用途,保持既有口径); * · 待验证域名组(新增):pending_domain / pending_verify_host / pending_verify_value / * pending_attempts / pending_last_error / pending_created_at / pending_active; * 无待验证域名时依次返回 '' / '' / '' / 0 / '' / null / false; * · 公共:cname(CNAME 目标)。 * 待验证域名的校验码始终回显(pending_domain 非空即有值):该域名尚未生效,用户需要据此配置 TXT。 * * @param {Object|null} record 配置记录实例(可为 null,返回空值默认)。 * @param {number} warehouseId 当前仓库 ID。 * @return {Object} 域名输出对象(生效组 + 待验证组 + cname)。 */ 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; const pendingDomain = hasRecord ? String(getValue('pending_domain') || '').trim() : ''; 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') || '') : '', // 待验证域名组(追加字段,不影响既有字段语义) pending_domain: pendingDomain, pending_verify_host: pendingDomain ? String(getValue('pending_verify_host') || '') : '', pending_verify_value: pendingDomain ? String(getValue('pending_verify_token') || '') : '', pending_attempts: hasRecord ? Number(getValue('pending_verify_attempts') || 0) : 0, pending_last_error: hasRecord ? String(getValue('pending_last_error') || '') : '', pending_created_at: hasRecord ? (getValue('pending_created_at') || null) : null, pending_active: !!pendingDomain, }; } /** * 规范化 checkDomain 回显的解析值(排障用:限量 + 截断,避免响应被超长/超多记录撑爆)。 * * @param {*} values 解析到的 TXT 值列表(可为空/非数组)。 * @return {string[]} 最多 DOMAIN_RESOLVED_VALUES_LIMIT 条、单条 ≤ DOMAIN_RESOLVED_VALUE_MAX_LENGTH 字符。 */ buildResolvedValues(values) { return (Array.isArray(values) ? values : []) .slice(0, DOMAIN_RESOLVED_VALUES_LIMIT) .map(value => String(value).slice(0, DOMAIN_RESOLVED_VALUE_MAX_LENGTH)); } /** * 域名状态→前端可读文案(用于 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)); } /** * 批量清理多个域名的公共拉取缓存(去重、忽略空值,单个失败仅记 WARN 不抛出)。 * * 顺序说明(重要):域名提升/切换必须先写库、后清缓存,且旧域名与新域名两个 key 都要清—— * 公共拉取缓存 key 按域名精确匹配(front:config:domain:{domain}),漏清旧域名会让已下线的 * 旧域名继续对外返回配置,漏清新域名则让新域名继续返回旧配置。 * * @param {string[]} domains 待清理域名列表(可含空值/重复项)。 * @param {string} [logTag] 日志前缀(定位调用方)。 * @return {Promise} 无返回值(绝不抛出)。 */ async clearDomainCaches(domains, logTag = 'FrontConfigService.clearDomainCaches') { const uniqueDomains = [ ...new Set( (Array.isArray(domains) ? domains : []) .map(item => String(item || '').trim()) .filter(item => !!item) ) ]; await Promise.all(uniqueDomains.map(domain => this.clearDomainCache(domain) .catch(error => { this.ctx.logger.warn('[%s] 清理前端配置缓存失败 domain=%s: %s', logTag, domain, error.message); }))); } /** * 构建「清空待验证域名」的更新字段(setDomain 取消待切换 与 promotePendingDomain 共用)。 * * 每次调用返回新对象,避免调用方误改共享字面量。 * * @return {Object} pending 6 列的清空字段(pending_verify_attempts 归 0,其余置 NULL)。 */ buildPendingClearPatch() { return { pending_domain: null, pending_verify_host: null, pending_verify_token: null, pending_verify_attempts: 0, pending_last_error: null, pending_created_at: null, }; } /** * 按域名查询前端配置(公共无鉴权接口业务实现,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 保存时置空,避免内容已换而路径陈旧,等待定时任务部署后回填真实路径; * 同时重置同步状态;写库成功后清理该域名的公共拉取缓存(先写库后清缓存)。 * * 两阶段域名切换提示:待验证域名提升(promotePendingDomain)时会清空证书 5 列并重置同步状态, * 用户必须为新域名重新上传证书;本接口前置闸门(无生效域名/未验证返回 400)与 SAN/CN 覆盖校验 * 始终以生效域名 domain 为准,存在 pending_domain 不影响本接口受理口径。 * * @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;