chanjs 2.8.3 → 2.8.5

package/core/Repository.js

@@ -188,21 +188,26 @@ class Repository extends BaseComponent {
     return row;
   }
 
-  /** 查询全部，默认上限1000条 */
-  async all({ query={}, sort={}, fields=[], limit=1000 }={}) {
+  /**
+   * 查询全部。上限口径统一收口到 config.LIMIT_MAX（this.limit）：
+   * 未传 limit 时默认取 this.limit；显式传入的 limit 也会被钳制到 [1, this.limit]，
+   * 避免"all 默认 1000 / 分页上限 300"两套口径并存。
+   */
+  async all({ query={}, sort={}, fields=[], limit }={}) {
     const err = this._guard({ query });
     if (err) return err;
-    const list = await this._buildBaseQuery({query,sort,fields}).limit(limit);
+    const size = Math.min(Math.max(Number(limit) || this.limit, 1), this.limit);
+    const list = await this._buildBaseQuery({query,sort,fields}).limit(size);
     return { success:true, code:CODE_OK, msg:"查询成功", data: list };
   }
 
-  /** 分页偏移查询 */
+  /** 分页偏移查询（limit 同 all() 口径，钳制到 config.LIMIT_MAX） */
   async find({ query={}, sort={}, fields=[], limit, offset }={}) {
     const err = this._guard({ query });
     if (err) return err;
     let q = this._buildBaseQuery({query,sort,fields});
     typeof offset === 'number' && (q = q.offset(offset));
-    typeof limit === 'number' && (q = q.limit(limit));
+    typeof limit === 'number' && (q = q.limit(Math.min(Math.max(limit, 1), this.limit)));
     return { success:true, code:CODE_OK, msg:"查询成功", data: await q };
   }
 

package/core/bootstrap/middleware.js

@@ -4,6 +4,7 @@ import {
 } from "../../middleware/index.js";
 import { health } from "../../middleware/health.js";
 import { BODY_LIMIT } from "../../config/index.js";
+import logger from "../../utils/logger.js";
 
 /**
  * 注册核心中间件（顺序固化：不可随意调整）
@@ -17,6 +18,19 @@ export async function registerCoreMiddleware(chan) {
   await waf(app, cfg.waf ?? { enabled: false });
   // 1.5 健康检查端点（默认开启，config.health = {enabled,path} 可调；浅模式零 IO）
   app.use(health(chan, cfg.health ?? {}));
+  // 1.6 宿主全局中间件插槽：config.middleware 数组，按声明顺序注册。
+  //     元素支持两种形态：express 中间件本身 (req,res,next)；或工厂 () => express 中间件（需闭包 chan/config 时用）。
+  //     注册位置在核心链早期、模块路由之前，保证对所有响应（含静态资源）生效。
+  //     注意：app/router.js（loadCommonRouter）的执行时机在模块路由之后，app.use 在那里
+  //     只罩得住 404 兜底请求，安全响应头等全局策略应经本插槽注册而非写在 router.js。
+  for (const mw of cfg.middleware ?? []) {
+    const fn = typeof mw === "function" && mw.length <= 1 ? mw(chan) : mw;
+    if (typeof fn !== "function") {
+      logger.warn(`[Chan] config.middleware 含非法项（须为中间件或中间件工厂），已跳过: ${String(mw)}`);
+      continue;
+    }
+    app.use(fn);
+  }
   // 2. Favicon
   favicon(app);
   // 3. 静态资源

package/doc/06-/345/272/224/347/224/250/347/224/237/345/221/275/345/221/250/346/234/237.md

@@ -172,7 +172,9 @@ const otherDb = app.dbManager.get("logs");
 | `REDIS_ENABLED` / `REDIS` | Redis 配置 |
 | `JWT_SECRET` | JWT 签名密钥 |
 | `LOCALE` | i18n 默认语言（默认 `zh-CN`）|
-| `LIMIT_MAX` | Repository 单页上限（默认 300）|
+| `LIMIT_MAX` | Repository 单页上限（默认 300）；`all()`/`find()` 显式 limit 亦被钳制到该值 |
+| `middleware` | 宿主全局中间件插槽：数组，元素为 express 中间件或中间件工厂 `(chan) => mw`，注册于核心链早期（健康检查后、静态资源前），对所有响应生效 |
+| `health` | 内置健康检查端点：`{ enabled: true, path: '/health' }`（默认值）。健全部署返回 HTTP **200**、degraded（含内部异常）返回 HTTP **503**，便于探针/负载均衡摘除实例。浅模式零 IO——只读进程内 DB 健康缓存，不实时 ping。`enabled: false` 可整体关闭，`path` 可改路径 |
 | `SLOW_THRESHOLD` | 数据库慢查询阈值（ms，默认 200），超过记 warn 日志 |
 | `SHUTDOWN_TIMEOUT` | 优雅停机强制退出超时（ms，默认 5000）|
 | `BODY_LIMIT` | 请求体上限（默认 `10mb`）|

package/middleware/header.js

@@ -1,20 +1,22 @@
 /**
- * 自定义响应头中间件，隐藏原生Express标识，统一输出ChanCMS
- * @param {express.Application} app Express实例
- * @param {{APP_NAME?: string, APP_VERSION?: string}} [opts] 配置选项
+ * 品牌响应头中间件：隐藏原生 Express 标识，统一输出 ChanCMS。
+ *
+ * 注：安全响应头（X-Content-Type-Options / HSTS / Referrer-Policy /
+ * Permissions-Policy / CSP 等）属于宿主业务策略，不在框架层默认设置——
+ * 由各项目的 security-headers 中间件统一收敛（本项目见 app/middleware/security-headers.js）。
+ * 尤其 CSP frame-ancestors 一旦在框架写死 'self'，会与需要被第三方
+ * iframe 嵌入的宿主业务直接冲突，故不在此声明。
  */
 export const header = (app, opts = {}) => {
   const appName = opts.APP_NAME || "ChanCMS";
   const appVer = opts.APP_VERSION || "";
   const poweredBy = appVer ? `${appName}/${appVer}` : appName;
+  // 静态资源在核心链第 3 步即被接住、到不了本中间件，Express 会默认补
+  // X-Powered-By: Express 泄露技术栈——先禁用默认注入，品牌头只由下方显式设置
+  app.disable("x-powered-by");
 
   app.use((_, res, next) => {
     res.setHeader("X-Powered-By", poweredBy);
-    // 常驻安全响应头：无论 WAF 是否启用都生效
-    // 禁止 MIME 嗅探（防 XSS 利用 Content-Type 歧义）
-    res.setHeader("X-Content-Type-Options", "nosniff");
-    // 防点击劫持：仅允许同源 iframe 嵌套（如需被第三方嵌入请按需放宽）
-    res.setHeader("Content-Security-Policy", "frame-ancestors 'self'");
     next();
   });
-};
+};

package/middleware/health.js

@@ -9,7 +9,11 @@ import { store } from "../storage/index.js";
  * DB 健康缓存由 error-handler 在真实查询成功/失败时维护（markUp/markDown）。
  *
  * 配置（config/index.js）：
- *   health: { enabled: true, path: '/health' }   // 默认值，可整体关闭或改路径
+ *   health: { enabled: true, path: '/health' }   // 默认值；enabled:false 可整体关闭，path 可改路径
+ *
+ * HTTP 状态码：健康 → 200；degraded（含内部异常）→ 503。
+ *   —— 探针/负载均衡据此摘除故障实例，故 degraded 必须体现为 503。
+ *   —— enabled:false 时注册的是透传中间件（不是不注册），保证 app.use() 始终拿到函数。
  *
  * 响应示例：
  *   { "success":true, "code":0, "msg":"ok", "data":{
@@ -18,12 +22,17 @@ import { store } from "../storage/index.js";
  *       "db":[{ "name":"default", "healthy":true }],
  *       "store":{ "mode":"memory", ... }
  *   } }
+ *   degraded 时：HTTP 503 + { "success":false, "code":5001, "msg":"degraded", ... }
  */
 
 const DEFAULT_PATH = "/health";
 
 export const health = (chan, opts = {}) => {
-  if (opts.enabled === false) return;
+  // 关闭时必须返回「合法中间件」，不能 return undefined：
+  // 调用方 core/bootstrap/middleware.js 是无条件 app.use(health(chan, cfg.health ?? {}))，
+  // 返回 undefined 会让 Express 抛 `TypeError: app.use() requires a middleware function`，
+  // 且发生在启动阶段 → 进程直接退出（配置项反而变成崩溃开关）。
+  if (opts.enabled === false) return (req, res, next) => next();
   const path = opts.path || DEFAULT_PATH;
   const startedAt = Date.now();
 
@@ -32,9 +41,11 @@ export const health = (chan, opts = {}) => {
     try {
       const db = chan.dbManager?.healthSnapshot?.() ?? [];
       const degraded = db.some(d => !d.healthy);
-      res.status(200).json({
-        success: true,
-        code: 0,
+      // 状态码必须反映真实健康度：degraded → 503。
+      // 旧实现恒 200，探针/负载均衡无法据此摘除故障实例（degraded 形同无效）。
+      res.status(degraded ? 503 : 200).json({
+        success: !degraded,
+        code: degraded ? 5001 : 0,
         msg: degraded ? "degraded" : "ok",
         data: {
           status: degraded ? "degraded" : "ok",
@@ -45,9 +56,10 @@ export const health = (chan, opts = {}) => {
       });
     } catch (err) {
       logger.error(`[Health] 健康检查异常：${err.message}`);
-      res.status(200).json({
-        success: true,
-        code: 0,
+      // 内部异常同样按「不可用」上报，不再伪装成 200
+      res.status(503).json({
+        success: false,
+        code: 5001,
         msg: "degraded",
         data: { status: "degraded", uptime: Math.floor((Date.now() - startedAt) / 1000), db: [], store: null },
       });

package/package.json

@@ -1,7 +1,7 @@
 {
   "type": "module",
   "name": "chanjs",
-  "version": "2.8.3",
+  "version": "2.8.5",
   "description": "chanjs基于 Node.js + Express 5 的标准 HMVC 框架（NHMVC），纯 JavaScript（ESM）开发。",
   "main": "index.js",
   "module": "index.js",

package/utils/request.js

@@ -5,6 +5,8 @@ import { promisify } from "util";
 const dnsLookup = promisify(dns.lookup);
 const DEFAULT_TIMEOUT = 10000;
 const MAX_RESPONSE_BYTES = 10 * 1024 * 1024;
+/** 重定向跳数上限（逐跳重新过 SSRF 校验） */
+const MAX_REDIRECTS = 5;
 
 /** IPv4 私网/回环段 */
 const IPV4_PRIVATE = /^(127\.|10\.|192\.168\.|172\.(1[6-9]|2\d|3[01])\.|169\.254\.|0\.0\.0\.0$)/;
@@ -38,6 +40,11 @@ async function isPrivateUrl(urlStr) {
 /**
  * HTTP 请求封装：超时/重试/SSRF 防护/大小限制
  * 支持 JSON 和原始数据（Buffer/文本）两种模式
+ *
+ * SSRF 防护是「逐跳」的：redirect 固定为 "manual"，重定向不自动跟随，
+ * 每一跳（含 302/301/307/308 的目标）都重新做协议白名单 + DNS 解析后 IP 校验，
+ * 跳数上限 MAX_REDIRECTS。调用方无法通过 options 覆盖 redirect。
+ *
  * @param {string} url - 请求地址
  * @param {Object} [options={}] - 请求配置
  * @param {number} [options.timeout=10000] - 超时时间(ms)
@@ -60,7 +67,7 @@ export async function request(url, options = {}) {
     ...rest
   } = options;
 
-  // SSRF 防护
+  // SSRF 防护（首跳；重定向目标在下方请求循环内逐跳校验）
   if (await isPrivateUrl(rawUrl)) {
     return { success: false, error: `SSRF防护拦截：${rawUrl}` };
   }
@@ -87,7 +94,43 @@ export async function request(url, options = {}) {
     const timer = timeout > 0 ? setTimeout(() => controller.abort(), timeout) : null;
 
     try {
-      const res = await fetch(rawUrl, { ...fetchOpts, signal: controller.signal });
+      // 重定向逐跳处理：redirect:"manual" 让 fetch 不自动跟随，由本循环接管，
+      // 并对「每一跳」重新做 SSRF 校验。
+      // 旧实现未设 redirect（默认 "follow"）且只校验了首个 URL ——
+      // 公网地址返回 302 指向 127.0.0.1 / 169.254.169.254 即可绕过防护。
+      // 注意：redirect 放在 ...fetchOpts 之后，调用方无法覆盖该安全约束。
+      let currentUrl = rawUrl;
+      let res;
+      for (let hop = 0; ; hop++) {
+        if (hop > MAX_REDIRECTS) {
+          if (timer) clearTimeout(timer);
+          return { success: false, error: `重定向次数超过上限(${MAX_REDIRECTS})：${rawUrl}` };
+        }
+        res = await fetch(currentUrl, { ...fetchOpts, redirect: "manual", signal: controller.signal });
+        // 非 3xx 即最终响应
+        if (!(res.status >= 300 && res.status < 400)) break;
+
+        const loc = res.headers.get("location");
+        // 释放重定向响应体，避免 socket 泄漏
+        try { await res.body?.cancel(); } catch { /* 已关闭则忽略 */ }
+        if (!loc) {
+          if (timer) clearTimeout(timer);
+          return { success: false, error: `HTTP ${res.status} 重定向缺少 Location 头` };
+        }
+        let next;
+        try {
+          next = new URL(loc, currentUrl).href; // 相对路径按当前 URL 补全
+        } catch {
+          if (timer) clearTimeout(timer);
+          return { success: false, error: `重定向地址非法：${loc}` };
+        }
+        // 关键：重定向目标必须重新过一遍 SSRF 校验（协议白名单 + DNS 解析后 IP 判定）
+        if (await isPrivateUrl(next)) {
+          if (timer) clearTimeout(timer);
+          return { success: false, error: `SSRF防护拦截（重定向目标）：${next}` };
+        }
+        currentUrl = next;
+      }
       if (timer) clearTimeout(timer);
 
       if (!res.ok) {