@kne/fastify-message 1.0.9 → 1.0.11

package/index.js

@@ -10,14 +10,18 @@ module.exports = fp(async function(fastify, options) {
       return fastify.account.models.user;
     }, senders: {}, getAuthenticate: (type) => {
       if (!fastify.account) {
-        throw new Error('fastify-account plugin must be registered before fastify-message,or set options.getAuthenticate');
+        return [() => {
+          throw new Error('fastify-account plugin must be registered before fastify-message,or set options.getAuthenticate');
+        }];
       }
       const { authenticate } = fastify.account;
       return [authenticate.user, authenticate.admin];
     }
   }, options);
 
-  fastify.register(require('@fastify/sse'));
+  fastify.register(require('@kne/fastify-statistics'), {
+    dbTableNamePrefix: options.dbTableNamePrefix, name: `${options.name}Statistics`
+  });
 
   fastify.register(require('@kne/fastify-namespace'), {
     name: options.name,

package/libs/controllers/main.js

@@ -156,125 +156,6 @@ module.exports = fp(async (fastify, options) => {
     }
   );
 
-  // 获取统计数据概览
-  fastify.get(
-    `${options.prefix}/statistics`,
-    {
-      onRequest: options.getAuthenticate('statistics'),
-      schema: {
-        description: '获取消息统计数据概览',
-        summary: '统计数据概览',
-          querystring: {
-          type: 'object',
-          properties: {
-            range: { type: 'string', default: '7d', description: '时间范围: 7d=近7天, 1m=近1个月, 1y=近1年' },
-            timezone: { type: 'string', description: '时区，如 Asia/Shanghai，默认服务器时区' }
-          }
-        },
-        response: {
-          200: {
-            type: 'object',
-            properties: {
-              range: { type: 'string', description: '当前时间范围' },
-              rangeLabel: { type: 'string', description: '时间范围描述' },
-              totalRecords: { type: 'integer', description: '时间范围内发送记录数' },
-              byType: {
-                type: 'object',
-                description: '按消息类型统计（0=邮件，1=短信）',
-                additionalProperties: { type: 'integer' }
-              },
-              byCode: {
-                type: 'object',
-                description: '按模板编码统计',
-                additionalProperties: { type: 'integer' }
-              },
-              templateStats: {
-                type: 'object',
-                properties: {
-                  total: { type: 'integer', description: '模板总数' },
-                  byStatus: {
-                    type: 'object',
-                    description: '按模板状态统计（0=启用，1=禁用）',
-                    additionalProperties: { type: 'integer' }
-                  },
-                  byType: {
-                    type: 'object',
-                    description: '按模板类型统计（0=邮件，1=短信）',
-                    additionalProperties: { type: 'integer' }
-                  }
-                }
-              },
-              recentTrend: {
-                type: 'array',
-                description: '时间范围内发送趋势',
-                items: {
-                  type: 'object',
-                  properties: {
-                    date: { type: 'string', description: '日期' },
-                    count: { type: 'integer', description: '发送数量' }
-                  }
-                }
-              },
-              recentTrendByType: {
-                type: 'array',
-                description: '时间范围内按类型发送趋势',
-                items: {
-                  type: 'object',
-                  properties: {
-                    date: { type: 'string', description: '日期' },
-                    type: { type: 'integer', description: '消息类型' },
-                    count: { type: 'integer', description: '发送数量' }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    },
-    async request => {
-      const { range = '7d', timezone } = request.query;
-      return await services.statistics.getOverview({ range, timezone });
-    }
-  );
-
-  // SSE 实时统计数据推送（当天实时数据）
-  fastify.get(
-    `${options.prefix}/statistics/sse`,
-    {
-      sse: true,
-      onRequest: options.getAuthenticate('statistics'),
-      schema: {
-        description: 'SSE实时推送当天消息统计数据',
-        summary: '实时统计数据SSE',
-          querystring: {
-          type: 'object',
-          properties: {
-            interval: { type: 'integer', minimum: 1, default: 5, description: '推送间隔时间（秒），最小1秒，默认5秒' },
-            timezone: { type: 'string', description: '时区，如 Asia/Shanghai，默认服务器时区' }
-          }
-        }
-      }
-    },
-    async function (request, reply) {
-      const intervalSeconds = request.query.interval ?? 5;
-      const { timezone } = request.query;
-
-      async function* eventStream() {
-        while (reply.sse.isConnected) {
-          try {
-            yield { data: JSON.stringify(await services.statistics.getRealtime({ timezone })) };
-          } catch (err) {
-            yield { event: 'error', data: JSON.stringify({ message: err.message }) };
-          }
-          await new Promise(resolve => setTimeout(resolve, intervalSeconds * 1000));
-        }
-      }
-
-      await reply.sse.send(eventStream());
-    }
-  );
-
   // 查看消息模版列表
   fastify.get(
     `${options.prefix}/templates`,

package/libs/controllers/statistics.js

@@ -0,0 +1,53 @@
+const fp = require('fastify-plugin');
+
+module.exports = fp(async (fastify, options) => {
+  const { services } = fastify[options.name];
+
+  fastify.get(
+    `${options.prefix}/statistics`,
+    {
+      onRequest: options.getAuthenticate('statistics'),
+      schema: {
+        summary: '获取消息统计概览',
+        query: {
+          type: 'object',
+          properties: {
+            range: { type: 'string', default: '7d', description: '时间范围: 7d=近7天, 1m=近1个月, 3m=近3个月, 1y=近1年' },
+            timezone: { type: 'string', description: '时区，如 Asia/Shanghai，默认服务器时区' },
+            type: { type: 'integer', description: '按消息类型筛选: 0=邮件, 1=短信' },
+            code: { type: 'string', description: '按模板编码筛选' }
+          }
+        }
+      }
+    },
+    async request => {
+      const { range = '7d', timezone, type, code } = request.query;
+      return await services.queryStatistics({ range, timezone, type, code });
+    }
+  );
+
+  // SSE 实时统计数据推送
+  fastify.get(
+    `${options.prefix}/statistics/sse`,
+    {
+      onRequest: options.getAuthenticate('statistics'),
+      schema: {
+        summary: 'SSE实时推送消息统计数据',
+        query: {
+          type: 'object',
+          properties: {
+            range: { type: 'string', default: '7d', description: '时间范围: 7d=近7天, 1m=近1个月, 3m=近3个月, 1y=近1年' },
+            timezone: { type: 'string', description: '时区，如 Asia/Shanghai，默认服务器时区' },
+            type: { type: 'integer', description: '按消息类型筛选: 0=邮件, 1=短信' },
+            code: { type: 'string', description: '按模板编码筛选' },
+            interval: { type: 'integer', minimum: 1, default: 5, description: '推送间隔时间（秒），最小1秒，默认5秒' }
+          }
+        }
+      }
+    },
+    async (request, reply) => {
+      const { range = '7d', timezone, type, code, interval } = request.query;
+      await services.sseStatistics({ range, timezone, type, code, interval }, reply);
+    }
+  );
+});

package/libs/services/main.js

@@ -5,38 +5,36 @@ const template = require('lodash/template');
 const merge = require('lodash/merge');
 const nodemailer = require('nodemailer');
 const { convert } = require('html-to-text');
-const dayjs = require('dayjs');
-const utc = require('dayjs/plugin/utc');
-const timezone = require('dayjs/plugin/timezone');
-
-dayjs.extend(utc);
-dayjs.extend(timezone);
 
 module.exports = fp(async (fastify, options) => {
-  // 按指定时区获取"今天0点"的UTC Date对象
-  const getTodayStart = tz => {
-    if (!tz) {
-      return dayjs().startOf('day').toDate();
-    }
-    // 在目标时区下取今天0点，再转回UTC
-    return dayjs().tz(tz).startOf('day').toDate();
-  };
-
-  // 按指定时区格式化日期
-  const formatDate = (date, tz) => {
-    if (!tz) {
-      return dayjs(date).format('YYYY-MM-DD');
-    }
-    return dayjs(date).tz(tz).format('YYYY-MM-DD');
-  };
-
-  const resolveTimezone = tz => tz || dayjs.tz.guess();
-
   const emailConfig = Object.assign({}, {
     port: 465, secure: true
   }, options.emailConfig);
   const isTest = options.isTest;
   const { models, services } = fastify[options.name];
+
+  // 采集消息统计数据
+  const collectMessageStatistics = async ({ code, type, success = true }) => {
+    try {
+      const statisticsServices = fastify[`${options.name}Statistics`]?.services;
+      if (!statisticsServices) return;
+
+      const data = { total: 1, success: success ? 1 : 0, failed: success ? 0 : 1 };
+      const unit = { total: 'count', success: 'count', failed: 'count' };
+      const time = new Date();
+
+      // 1-segment channel: code
+      await statisticsServices.collect({
+        channel: code, data, unit, time
+      });
+      // 2-segment channel: code:type
+      await statisticsServices.collect({
+        channel: `${code}:${type}`, data, unit, time
+      });
+    } catch (e) {
+      fastify.log.error(`采集消息统计数据失败: ${e.message}`);
+    }
+  };
   const includeTemplate = async dir => {
     if (!(await fs.exists(dir))) {
       fastify.log.info('template dir not exists');
@@ -147,6 +145,7 @@ module.exports = fp(async (fastify, options) => {
       throw new Error(`未配置类型 ${type} 的消息发送器`);
     })(type);
     await models.record.create({ type, code, templateId, props, name, content: sendOptions });
+    await collectMessageStatistics({ code, type, success: true });
   };
 
   Object.assign(fastify[options.name].services, {
@@ -178,253 +177,6 @@ module.exports = fp(async (fastify, options) => {
         return record;
       }
     },
-    
-    // 统计相关服务
-    statistics: {
-      getOverview: async ({ range = '7d', timezone } = {}) => {
-        const { Sequelize } = models.record.sequelize;
-        const recordModel = models.record;
-        const templateModel = models.template;
-        const createdAtCol = recordModel.rawAttributes.createdAt.field;
-        const dialect = recordModel.sequelize.getDialect();
-        const effectiveTimezone = resolveTimezone(timezone);
-
-        // 根据range计算起始时间
-        const rangeMap = {
-          '7d': { days: 7, label: '近7天' },
-          '1m': { days: 30, label: '近1个月' },
-          '1y': { days: 365, label: '近1年' }
-        };
-        const normalizedRange = rangeMap[range] ? range : '7d';
-        const rangeConfig = rangeMap[normalizedRange];
-        // 按时区计算起始日期：先获取目标时区"今天0点"的UTC时间，再往前推N天
-        const todayStart = getTodayStart(effectiveTimezone);
-        const startDate = new Date(todayStart);
-        startDate.setDate(startDate.getDate() - rangeConfig.days);
-
-        const whereRange = { createdAt: { [Sequelize.Op.gte]: startDate } };
-
-        // 按时区格式化日期的SQL：SQLite用strftime+utc偏移，MySQL用DATE_FORMAT+CONVERT_TZ，PostgreSQL用TO_CHAR+AT TIME ZONE
-        const dateFn = (() => {
-          if (!effectiveTimezone || dialect === 'sqlite') {
-            return col => Sequelize.fn('DATE', Sequelize.col(col));
-          }
-          if (dialect === 'postgres') {
-            return col => Sequelize.fn('TO_CHAR', Sequelize.literal(`"${col}" AT TIME ZONE '${effectiveTimezone}'`), 'YYYY-MM-DD');
-          }
-          return col => Sequelize.fn('DATE_FORMAT', Sequelize.fn('CONVERT_TZ', Sequelize.col(col), '+00:00', Sequelize.literal(`'${effectiveTimezone}'`)), '%Y-%m-%d');
-        })();
-
-        // 并行执行所有查询
-        const [totalRecords, byType, byCode, totalTemplates, templatesByStatus, templatesByType, recentTrend, recentTrendByType] = await Promise.all([
-          recordModel.count({ where: whereRange }),
-          recordModel.findAll({
-            attributes: ['type', [Sequelize.fn('COUNT', Sequelize.col('id')), 'count']],
-            where: whereRange,
-            group: ['type'],
-            raw: true
-          }),
-          recordModel.findAll({
-            attributes: ['code', [Sequelize.fn('COUNT', Sequelize.col('id')), 'count']],
-            where: whereRange,
-            group: ['code'],
-            raw: true
-          }),
-          templateModel.count(),
-          templateModel.findAll({
-            attributes: ['status', [Sequelize.fn('COUNT', Sequelize.col('id')), 'count']],
-            group: ['status'],
-            raw: true
-          }),
-          templateModel.findAll({
-            attributes: ['type', [Sequelize.fn('COUNT', Sequelize.col('id')), 'count']],
-            group: ['type'],
-            raw: true
-          }),
-          recordModel.findAll({
-            attributes: [
-              [dateFn(createdAtCol), 'date'],
-              [Sequelize.fn('COUNT', Sequelize.col('id')), 'count']
-            ],
-            where: whereRange,
-            group: [dateFn(createdAtCol)],
-            order: [[dateFn(createdAtCol), 'ASC']],
-            raw: true
-          }),
-          recordModel.findAll({
-            attributes: [
-              [dateFn(createdAtCol), 'date'],
-              'type',
-              [Sequelize.fn('COUNT', Sequelize.col('id')), 'count']
-            ],
-            where: whereRange,
-            group: [dateFn(createdAtCol), 'type'],
-            order: [[dateFn(createdAtCol), 'ASC']],
-            raw: true
-          })
-        ]);
-
-        // SQLite 需要在JS层做时区偏移修正DATE结果
-        const adjustDate = dateStr => {
-          if (!effectiveTimezone || dialect !== 'sqlite') return dateStr;
-          // SQLite DATE返回UTC日期，用dayjs转到目标时区取日期
-          return dayjs.utc(dateStr).tz(effectiveTimezone).format('YYYY-MM-DD');
-        };
-
-        return {
-          range: normalizedRange,
-          rangeLabel: rangeConfig.label,
-          totalRecords,
-          byType: byType.reduce((acc, item) => {
-            acc[String(item.type)] = Number(item.count);
-            return acc;
-          }, {}),
-          byCode: byCode.reduce((acc, item) => {
-            acc[item.code] = Number(item.count);
-            return acc;
-          }, {}),
-          templateStats: {
-            total: totalTemplates,
-            byStatus: templatesByStatus.reduce((acc, item) => {
-              acc[String(item.status)] = Number(item.count);
-              return acc;
-            }, {}),
-            byType: templatesByType.reduce((acc, item) => {
-              acc[String(item.type)] = Number(item.count);
-              return acc;
-            }, {})
-          },
-          recentTrend: recentTrend.map(item => ({ date: adjustDate(item.date), count: Number(item.count) })),
-          recentTrendByType: recentTrendByType.map(item => ({ date: adjustDate(item.date), type: item.type, count: Number(item.count) }))
-        };
-      },
-
-      getRealtime: async ({ timezone } = {}) => {
-        const { Sequelize } = models.record.sequelize;
-        const recordModel = models.record;
-        const createdAtCol = recordModel.rawAttributes.createdAt.field;
-        const dialect = recordModel.sequelize.getDialect();
-        const effectiveTimezone = resolveTimezone(timezone);
-
-        // 当天起始时间（按指定时区）
-        const todayStart = getTodayStart(effectiveTimezone);
-
-        const whereToday = { createdAt: { [Sequelize.Op.gte]: todayStart } };
-
-        // SQLite: strftime取UTC时间后JS层偏移；MySQL: CONVERT_TZ转时区后提取；PostgreSQL: AT TIME ZONE转时区后提取
-        const hourExtract = (() => {
-          if (!effectiveTimezone || dialect === 'sqlite') {
-            return dialect === 'sqlite'
-              ? Sequelize.fn('strftime', '%H', Sequelize.col(createdAtCol))
-              : Sequelize.fn('EXTRACT', Sequelize.literal(`HOUR FROM "${createdAtCol}"`));
-          }
-          if (dialect === 'postgres') {
-            return Sequelize.fn('EXTRACT', Sequelize.literal(`HOUR FROM "${createdAtCol}" AT TIME ZONE '${effectiveTimezone}'`));
-          }
-          return Sequelize.fn('EXTRACT', Sequelize.literal(`HOUR FROM CONVERT_TZ("${createdAtCol}", '+00:00', '${effectiveTimezone}')`));
-        })();
-
-        // 15分钟间隔提取：SQLite用strftime，MySQL用DATE_FORMAT+EXTRACT，PostgreSQL用TO_CHAR+EXTRACT
-        const intervalExtract = (() => {
-          if (dialect === 'sqlite') {
-            return Sequelize.literal(`strftime('%H', "${createdAtCol}") || ':' || printf('%02d', CAST(strftime('%M', "${createdAtCol}") AS INTEGER) / 15 * 15)`);
-          }
-          if (!effectiveTimezone) {
-            if (dialect === 'postgres') {
-              return Sequelize.literal(`TO_CHAR("${createdAtCol}", 'HH24:') || LPAD((FLOOR(EXTRACT(MINUTE FROM "${createdAtCol}") / 15) * 15)::TEXT, 2, '0')`);
-            }
-            return Sequelize.literal(`CONCAT(DATE_FORMAT("${createdAtCol}", '%H:'), LPAD(FLOOR(EXTRACT(MINUTE FROM "${createdAtCol}") / 15) * 15, 2, '0'))`);
-          }
-          if (dialect === 'postgres') {
-            return Sequelize.literal(`TO_CHAR("${createdAtCol}" AT TIME ZONE '${effectiveTimezone}', 'HH24:') || LPAD((FLOOR(EXTRACT(MINUTE FROM "${createdAtCol}" AT TIME ZONE '${effectiveTimezone}') / 15) * 15)::TEXT, 2, '0')`);
-          }
-          return Sequelize.literal(`CONCAT(DATE_FORMAT(CONVERT_TZ("${createdAtCol}", '+00:00', '${effectiveTimezone}'), '%H:'), LPAD(FLOOR(EXTRACT(MINUTE FROM CONVERT_TZ("${createdAtCol}", '+00:00', '${effectiveTimezone}')) / 15) * 15, 2, '0'))`);
-        })();
-
-        const [totalRecords, byType, byCode, hourlyTrend, hourlyTrendByType, intervalTrend] = await Promise.all([
-          recordModel.count({ where: whereToday }),
-          recordModel.findAll({
-            attributes: ['type', [Sequelize.fn('COUNT', Sequelize.col('id')), 'count']],
-            where: whereToday,
-            group: ['type'],
-            raw: true
-          }),
-          recordModel.findAll({
-            attributes: ['code', [Sequelize.fn('COUNT', Sequelize.col('id')), 'count']],
-            where: whereToday,
-            group: ['code'],
-            raw: true
-          }),
-          recordModel.findAll({
-            attributes: [
-              [hourExtract, 'hour'],
-              [Sequelize.fn('COUNT', Sequelize.col('id')), 'count']
-            ],
-            where: whereToday,
-            group: [hourExtract],
-            order: [[hourExtract, 'ASC']],
-            raw: true
-          }),
-          recordModel.findAll({
-            attributes: [
-              [hourExtract, 'hour'],
-              'type',
-              [Sequelize.fn('COUNT', Sequelize.col('id')), 'count']
-            ],
-            where: whereToday,
-            group: [hourExtract, 'type'],
-            order: [[hourExtract, 'ASC'], ['type', 'ASC']],
-            raw: true
-          }),
-          recordModel.findAll({
-            attributes: [
-              [intervalExtract, 'interval'],
-              [Sequelize.fn('COUNT', Sequelize.col('id')), 'count']
-            ],
-            where: whereToday,
-            group: [intervalExtract],
-            order: [[intervalExtract, 'ASC']],
-            raw: true
-          })
-        ]);
-
-        // SQLite的hour/interval是UTC，需按timezone偏移修正
-        const adjustHour = hour => {
-          if (!effectiveTimezone || dialect !== 'sqlite') return Number(hour);
-          // 构建一个UTC时间点（今天+hour:00），转目标时区后取hour
-          const utcTime = dayjs.utc().startOf('day').hour(Number(hour));
-          return utcTime.tz(effectiveTimezone).hour();
-        };
-
-        const adjustInterval = intervalStr => {
-          if (!effectiveTimezone || dialect !== 'sqlite') return intervalStr;
-          const [h, m] = intervalStr.split(':').map(Number);
-          // 构建一个UTC时间点（今天+hour:minute），转目标时区后格式化
-          const utcTime = dayjs.utc().startOf('day').hour(h).minute(m);
-          return utcTime.tz(effectiveTimezone).format('HH:mm');
-        };
-
-        return {
-          date: formatDate(todayStart, effectiveTimezone),
-          totalRecords,
-          byType: byType.reduce((acc, item) => {
-            acc[String(item.type)] = Number(item.count);
-            return acc;
-          }, {}),
-          byCode: byCode.reduce((acc, item) => {
-            acc[item.code] = Number(item.count);
-            return acc;
-          }, {}),
-          hourlyTrend: hourlyTrend.map(item => ({ hour: adjustHour(item.hour), count: Number(item.count) })),
-          hourlyTrendByType: hourlyTrendByType.map(item => ({
-            hour: adjustHour(item.hour),
-            type: Number(item.type),
-            count: Number(item.count)
-          })),
-          intervalTrend: intervalTrend.map(item => ({ interval: adjustInterval(item.interval), count: Number(item.count) }))
-        };
-      }
-    },
 
     // 消息模版相关服务
     template: {

package/libs/services/statistics.js

@@ -0,0 +1,328 @@
+const fp = require('fastify-plugin');
+const dayjs = require('dayjs');
+const utc = require('dayjs/plugin/utc');
+const timezone = require('dayjs/plugin/timezone');
+const {
+  CONFIG_CONSTANTS
+} = require('../utils/config');
+
+dayjs.extend(utc);
+dayjs.extend(timezone);
+
+// 查询用客户端时间：parseRange 使用客户端时区计算日期范围
+const parseRange = (range = '7d', tz) => {
+  const config = CONFIG_CONSTANTS.TIME_RANGES[range];
+  if (!config) {
+    throw new Error(`不支持的时间范围: ${range}, 支持: ${Object.keys(CONFIG_CONSTANTS.TIME_RANGES).join(',')}`);
+  }
+  // 写入数据全使用服务器时间，查询用客户端时间
+  const now = tz ? dayjs().tz(tz) : dayjs();
+  const unitStartMap = { day: 'day', month: 'month', year: 'year' };
+  const startUnit = unitStartMap[config.unit];
+  const startTime = startUnit
+    ? now.subtract(config.value, startUnit).startOf(startUnit)
+    : now.subtract(config.value, config.unit);
+  return { startTime: startTime.toDate(), endTime: now.toDate(), label: config.label, range };
+};
+
+// 查询用客户端时间：formatDate 使用客户端时区格式化日期
+const formatDate = (date, tz) => {
+  const d = tz ? dayjs(date).tz(tz) : dayjs(date);
+  return d.format('YYYY-MM-DD');
+};
+
+// 查询用客户端时间：提取客户端时区下的小时
+const getHour = (date, tz) => {
+  const d = tz ? dayjs(date).tz(tz) : dayjs(date);
+  return d.hour();
+};
+
+const safeNum = v => {
+  const n = Number(v);
+  return (typeof n === 'number' && !isNaN(n) ? n : 0);
+};
+
+const getSumData = item => (item.data || {}).sum || item.data || {};
+
+// channel 格式: "code" (1段) 或 "code:type" (2段)
+// code = 模板编码, type = 消息类型 (0=邮件, 1=短信)
+const parseChannel = channel => {
+  const parts = channel.split(':');
+  return parts.length >= 2
+    ? { code: parts[0], type: parts[1] }
+    : { code: channel, type: null };
+};
+
+const buildChannels = async (statisticsServices, code, type) => {
+  const metaResult = await statisticsServices.channelMeta.list();
+  const list = Array.isArray(metaResult) ? metaResult : metaResult.list || [];
+  const rootChannels = list.map(meta => meta.channel).filter(Boolean);
+  const codes = code ? rootChannels.filter(ch => ch === code) : rootChannels;
+  const messageTypes = type !== undefined && type !== null ? [String(type)] : ['0', '1'];
+  const channels = [];
+  for (const c of codes) {
+    channels.push(c);
+    for (const mt of messageTypes) channels.push(`${c}:${mt}`);
+  }
+  return channels;
+};
+
+// 创建空的 dailyMap 条目
+const createDailyMapEntry = () => ({
+  total: 0,
+  byType: {}
+});
+
+// 查询 statistics 并解析结果
+const queryAndParse = async (statisticsServices, { channels, startTime, endTime, timezone: tz, type: typeFilter }) => {
+  if (channels.length === 0) return null;
+
+  const statResult = await statisticsServices.query({
+    channels, startTime, endTime,
+    attributeNames: CONFIG_CONSTANTS.STATISTICS_ATTRIBUTES,
+    aggregates: ['sum'],
+    timezone: tz || undefined
+  });
+
+  const result = {
+    totalRecords: 0,
+    byType: {},
+    byCode: {},
+    dailyMap: {},
+    hourlyMap: {},
+    hourlyTypeMap: {}
+  };
+
+  for (const item of statResult.list || []) {
+    const { code: codeName, type: typeName } = parseChannel(item.channel);
+    if (typeFilter !== undefined && typeFilter !== null && typeName && typeName !== String(typeFilter)) continue;
+    if (typeFilter !== undefined && typeFilter !== null && !typeName) continue;
+
+    const sum = getSumData(item);
+    const count = safeNum(sum.total);
+    const isHourly = item.period === 'h';
+    const date = formatDate(item.time, tz);
+    const hour = isHourly ? getHour(item.time, tz) : null;
+
+    // ─── 1-segment channel: 全局 + 按日 聚合 ───
+    if (!typeName) {
+      result.totalRecords += count;
+      result.byCode[codeName] = (result.byCode[codeName] || 0) + count;
+
+      // 按日汇总
+      if (!result.dailyMap[date]) result.dailyMap[date] = createDailyMapEntry();
+      result.dailyMap[date].total += count;
+
+      // 小时级趋势（仅 period='h'）
+      if (isHourly) {
+        if (!result.hourlyMap[date]) result.hourlyMap[date] = {};
+        result.hourlyMap[date][hour] = (result.hourlyMap[date][hour] || 0) + count;
+      }
+    }
+
+    // ─── 2-segment channel: byType 聚合 ───
+    if (typeName) {
+      result.byType[typeName] = (result.byType[typeName] || 0) + count;
+
+      if (result.dailyMap[date]) {
+        result.dailyMap[date].byType[typeName] = (result.dailyMap[date].byType[typeName] || 0) + count;
+      }
+
+      if (isHourly) {
+        if (!result.hourlyTypeMap[date]) result.hourlyTypeMap[date] = {};
+        if (!result.hourlyTypeMap[date][hour]) result.hourlyTypeMap[date][hour] = {};
+        result.hourlyTypeMap[date][hour][typeName] = (result.hourlyTypeMap[date][hour][typeName] || 0) + count;
+      }
+    }
+  }
+
+  return result;
+};
+
+// 构建历史日趋势数组
+const buildDailyTrendArrays = (parsed) => {
+  const sorted = Object.entries(parsed.dailyMap).sort(([a], [b]) => a.localeCompare(b));
+  const recentTrend = sorted.map(([date, d]) => ({ date, count: d.total }));
+  const recentTrendByType = [];
+  sorted.forEach(([date, d]) => {
+    Object.entries(d.byType).forEach(([type, count]) => recentTrendByType.push({ date, type: Number(type), count }));
+  });
+  return { recentTrend, recentTrendByType };
+};
+
+// 构建小时趋势数组
+const buildHourlyTrendArrays = (parsed, todayStr) => {
+  const hourlyTrend = [];
+  const hourlyTrendByType = [];
+
+  const dates = Object.keys(parsed.hourlyMap).sort();
+  for (const date of dates) {
+    const hoursMap = parsed.hourlyMap[date] || {};
+    const typeMap = parsed.hourlyTypeMap[date] || {};
+
+    // 只处理当天的数据（SSE 场景），或所有数据（历史场景）
+    const allHours = [...new Set([
+      ...Object.keys(hoursMap).map(Number),
+      ...Object.keys(typeMap).reduce((acc, h) => {
+        acc.push(Number(h));
+        return acc;
+      }, [])
+    ])].sort((a, b) => a - b);
+
+    for (const hour of allHours) {
+      if (todayStr && date !== todayStr) continue;
+      hourlyTrend.push({
+        date, hour,
+        count: hoursMap[hour] || 0
+      });
+
+      const types = typeMap[hour] || {};
+      for (const [typeName, count] of Object.entries(types)) {
+        if (count > 0) hourlyTrendByType.push({ date, hour, type: Number(typeName), count });
+      }
+    }
+  }
+
+  return { hourlyTrend, hourlyTrendByType };
+};
+
+module.exports = fp(async (fastify, options) => {
+  const statisticsServices = fastify[`${options.name}Statistics`].services;
+  const { template: TemplateModel } = fastify[options.name].models;
+  const { Sequelize } = TemplateModel.sequelize;
+
+  // ─── queryStatistics (history 接口) ───
+  const queryStatistics = async ({ range = '7d', timezone, type, code }) => {
+    const { startTime, endTime, label, range: rangeKey } = parseRange(range, timezone);
+    const emptyResult = {
+      range: rangeKey, rangeLabel: label,
+      totalRecords: 0, byType: {}, byCode: {},
+      recentTrend: [], recentTrendByType: [],
+      hourlyTrend: [], hourlyTrendByType: [],
+      templateStats: { total: 0, byStatus: {}, byType: {} }
+    };
+    try {
+      const channels = await buildChannels(statisticsServices, code, type);
+      const parsed = await queryAndParse(statisticsServices, { channels, startTime, endTime, timezone, type });
+      if (!parsed) return emptyResult;
+
+      const { recentTrend, recentTrendByType } = buildDailyTrendArrays(parsed);
+      const { hourlyTrend, hourlyTrendByType } = buildHourlyTrendArrays(parsed);
+
+      // 查询模板统计（独立于 statistics 服务）
+      const [totalTemplates, templatesByStatus, templatesByType] = await Promise.all([
+        TemplateModel.count(),
+        TemplateModel.findAll({
+          attributes: ['status', [Sequelize.fn('COUNT', Sequelize.col('id')), 'count']],
+          group: ['status'],
+          raw: true
+        }),
+        TemplateModel.findAll({
+          attributes: ['type', [Sequelize.fn('COUNT', Sequelize.col('id')), 'count']],
+          group: ['type'],
+          raw: true
+        })
+      ]);
+
+      return {
+        range: rangeKey, rangeLabel: label,
+        totalRecords: parsed.totalRecords,
+        byType: parsed.byType,
+        byCode: parsed.byCode,
+        recentTrend, recentTrendByType,
+        hourlyTrend, hourlyTrendByType,
+        templateStats: {
+          total: totalTemplates,
+          byStatus: templatesByStatus.reduce((acc, item) => {
+            acc[String(item.status)] = Number(item.count);
+            return acc;
+          }, {}),
+          byType: templatesByType.reduce((acc, item) => {
+            acc[String(item.type)] = Number(item.count);
+            return acc;
+          }, {})
+        }
+      };
+    } catch (e) {
+      fastify.log.error(`查询统计数据失败: ${e.message}`);
+      return emptyResult;
+    }
+  };
+
+  // ─── buildSseData (SSE 接口) ───
+  const buildSseData = async ({ timezone: tz, type, code }) => {
+    // 查询用客户端时间："今天"的边界使用客户端时区
+    const now = tz ? dayjs().tz(tz) : dayjs();
+    const todayStart = now.startOf('day').toDate();
+    const todayEnd = now.endOf('day').toDate();
+    const todayStr = now.format('YYYY-MM-DD');
+
+    // 默认值
+    let totalRecords = 0;
+    let byType = {};
+    let byCode = {};
+    let hourlyTrend = [];
+    let hourlyTrendByType = [];
+    let intervalTrend = [];
+
+    try {
+      const channels = await buildChannels(statisticsServices, code, type);
+      const parsed = await queryAndParse(statisticsServices, { channels, startTime: todayStart, endTime: todayEnd, timezone: tz, type });
+      if (parsed) {
+        totalRecords = parsed.totalRecords;
+        byType = parsed.byType;
+        byCode = parsed.byCode;
+
+        const hourlyArrays = buildHourlyTrendArrays(parsed, todayStr);
+
+        // SSE 格式：简化为 {hour, count}
+        hourlyTrend = hourlyArrays.hourlyTrend
+          .filter(h => h.date === todayStr)
+          .map(({ hour, count }) => ({ hour, count }));
+
+        hourlyTrendByType = hourlyArrays.hourlyTrendByType
+          .filter(h => h.date === todayStr)
+          .map(({ hour, type, count }) => ({ hour, type, count }));
+
+        intervalTrend = hourlyTrend.map(({ hour, count }) => ({
+          interval: `${String(hour).padStart(2, '0')}:00`,
+          count
+        }));
+      }
+    } catch (e) {
+      fastify.log.error(`SSE统计查询失败: ${e.message}`);
+    }
+
+    return {
+      date: todayStr,
+      totalRecords,
+      byType,
+      byCode,
+      hourlyTrend,
+      hourlyTrendByType,
+      intervalTrend
+    };
+  };
+
+  // ─── sseStatistics ───
+  const sseStatistics = async ({ range = '7d', timezone, type, code, interval }, reply) => {
+    await statisticsServices.sseStream.send(reply, {
+      name: `${options.name}Statistics`,
+      params: { type, code, timezone },
+      fetchData: async ({ type, code, timezone } = {}) => {
+        try {
+          return await buildSseData({ timezone, type, code });
+        } catch (e) {
+          fastify.log.error(`SSE获取数据失败: ${e.message}`);
+          return {};
+        }
+      },
+      interval: interval || 5
+    });
+  };
+
+  Object.assign(fastify[options.name].services, {
+    queryStatistics,
+    sseStatistics
+  });
+});

package/libs/utils/config.js

@@ -0,0 +1,18 @@
+/**
+ * 配置常量定义
+ */
+const CONFIG_CONSTANTS = {
+  // 时间范围
+  TIME_RANGES: {
+    '7d': { value: 7, unit: 'day', label: '近7天' },
+    '1m': { value: 1, unit: 'month', label: '近1个月' },
+    '3m': { value: 3, unit: 'month', label: '近3个月' },
+    '1y': { value: 1, unit: 'year', label: '近1年' }
+  },
+
+  // 统计相关
+  STATISTICS_ATTRIBUTES: ['total', 'success', 'failed'],
+  STATISTICS_PERIODS: ['h', 'd']
+};
+
+module.exports = { CONFIG_CONSTANTS };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kne/fastify-message",
-  "version": "1.0.9",
+  "version": "1.0.11",
   "description": "管理消息发送，支持sms消息，email消息等.",
   "main": "index.js",
   "scripts": {
@@ -49,6 +49,7 @@
     "@kne/fastify-sequelize": "^2.0.1",
     "chai": "^6.2.2",
     "fastify": "^5.3.2",
+    "fastify-cron": "^1.4.0",
     "fastify-plugin": "^5.0.1",
     "husky": "^9.0.11",
     "mocha": "^11.7.5",
@@ -59,7 +60,7 @@
     "sqlite3": "^6.0.1"
   },
   "dependencies": {
-    "@fastify/sse": "^0.4.0",
+    "@kne/fastify-statistics": "^0.1.0-alpha.10",
     "dayjs": "^1.11.20",
     "fs-extra": "^11.3.0",
     "html-to-text": "^9.0.5",