@kne/fastify-message 1.0.6 → 1.0.8

package/index.js

@@ -17,6 +17,8 @@ module.exports = fp(async function(fastify, options) {
     }
   }, options);
 
+  fastify.register(require('@fastify/sse'));
+
   fastify.register(require('@kne/fastify-namespace'), {
     name: options.name,
     options,
@@ -25,7 +27,7 @@ module.exports = fp(async function(fastify, options) {
     })], ['services', path.resolve(__dirname, './libs/services')], ['controllers', path.resolve(__dirname, './libs/controllers')]]
   });
 
-  fastify.register(fp((fastify, options) => {
+  fastify.register(fp(async (fastify, options) => {
     fastify.sequelize.syncPromise.then(() => {
       return fastify[options.name].services.includeTemplate(options.templateDir);
     });

package/libs/controllers/main.js

@@ -64,7 +64,7 @@ module.exports = fp(async (fastify, options) => {
       if (code) where.code = code;
       if (name) where.name = name;
       
-      return await services.record.list({ filter: where, perPage, currentPage });
+      return await services.record.list({ filter: where, perPage: Math.min(perPage, 100), currentPage });
     }
   );
 
@@ -103,7 +103,10 @@ module.exports = fp(async (fastify, options) => {
         if (error.message === '模版已禁用，无法发送消息') {
           throw fastify.httpErrors.badRequest(error.message);
         }
-        throw fastify.httpErrors.notFound(error.message);
+        if (error.message === '模版不存在' || error.message === 'template not found') {
+          throw fastify.httpErrors.notFound(error.message);
+        }
+        throw error;
       }
     }
   );
@@ -145,11 +148,134 @@ module.exports = fp(async (fastify, options) => {
       try {
         return await services.record.detail({ id });
       } catch (error) {
-        throw fastify.httpErrors.notFound(error.message);
+        if (error.message === '记录不存在') {
+          throw fastify.httpErrors.notFound(error.message);
+        }
+        throw error;
       }
     }
   );
 
+  // 获取统计数据概览
+  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;
+      const { timezone } = request.query;
+      reply.sse.keepAlive();
+
+      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`,
@@ -213,7 +339,7 @@ module.exports = fp(async (fastify, options) => {
       if (level !== undefined) where.level = level;
       if (status !== undefined) where.status = status;
       
-      return await services.template.list({ filter: where, perPage, currentPage });
+      return await services.template.list({ filter: where, perPage: Math.min(perPage, 100), currentPage });
     }
   );
 
@@ -254,7 +380,10 @@ module.exports = fp(async (fastify, options) => {
       try {
         return await services.template.detail({ id });
       } catch (error) {
-        throw fastify.httpErrors.notFound(error.message);
+        if (error.message === '模版不存在') {
+          throw fastify.httpErrors.notFound(error.message);
+        }
+        throw error;
       }
     }
   );

package/libs/models/record.js

@@ -31,7 +31,13 @@ module.exports = ({ DataTypes, options }) => {
       record.belongsTo(template);
     },
     options: {
-      comment: '系统消息记录'
+      comment: '系统消息记录',
+      indexes: [
+        { fields: ['created_at'] },
+        { fields: ['type'] },
+        { fields: ['code'] },
+        { fields: ['type', 'code'] }
+      ]
     }
   };
 };

package/libs/models/template.js

@@ -37,7 +37,10 @@ module.exports = ({ DataTypes, options }) => {
       });
     },
     options: {
-      comment: '消息模版'
+      comment: '消息模版',
+      indexes: [
+        { fields: ['code', 'type', 'level'] }
+      ]
     }
   };
 };

package/libs/services/main.js

@@ -5,9 +5,33 @@ const template = require('lodash/template');
 const merge = require('lodash/merge');
 const nodemailer = require('nodemailer');
 const { convert } = require('html-to-text');
-const pify = require('pify');
+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);
@@ -15,17 +39,19 @@ module.exports = fp(async (fastify, options) => {
   const { models, services } = fastify[options.name];
   const includeTemplate = async dir => {
     if (!(await fs.exists(dir))) {
-      console.log('template dir not exists');
+      fastify.log.info('template dir not exists');
       return;
     }
-    console.log('------start include template------');
+    fastify.log.info('------start include template------');
     const list = await fs.readdir(dir);
     for (const file of list) {
       const filePath = path.join(dir, file);
+      const stat = await fs.stat(filePath);
+      if (!stat.isFile()) continue;
       const content = await fs.readFile(filePath, 'utf8');
       const filename = file.replace(path.extname(file), '');
       const tempArray = filename.split('_');
-      const code = tempArray[0], type = tempArray[1] || 0, name = tempArray[2] || code;
+      const code = tempArray[0], type = Number(tempArray[1]) || 0, name = tempArray[2] || code;
       const codeTemplate = await models.template.findOne({
         where: {
           code, type, level: 0
@@ -36,15 +62,15 @@ module.exports = fp(async (fastify, options) => {
         codeTemplate.content = content;
         codeTemplate.name = name;
         await codeTemplate.save();
-        console.log(`update template: ${code}`);
+        fastify.log.info(`update template: ${code}`);
         continue;
       }
       await models.template.create({
         code, type, name, content, level: 0
       });
-      console.log(`create template: ${code}`);
+      fastify.log.info(`create template: ${code}`);
     }
-    console.log('------end include template------');
+    fastify.log.info('------end include template------');
   };
 
   const parseTemplate = text => {
@@ -70,7 +96,7 @@ module.exports = fp(async (fastify, options) => {
       throw new Error('template not found');
     }
 
-    const content = parseTemplate(template(codeTemplate.content)(props).split(/<!--(\s*)-->/g));
+    const content = parseTemplate(template(codeTemplate.content)(props));
 
     return {
       content, props, code, type, templateId: codeTemplate.id
@@ -103,19 +129,22 @@ module.exports = fp(async (fastify, options) => {
               }
             }, client);
             const smtp = nodemailer.createTransport(currentClient);
-            await pify(smtp.sendMail.bind(smtp))(mailOptions);
+            try {
+              await smtp.sendMail(mailOptions);
+            } finally {
+              smtp.close();
+            }
           }
         }
         return mailOptions;
       }
       if (typeof currentSender === 'function') {
-        const { content, templateId } = await messageTemplate({ code, type, level, props });
         if (!isTest) {
           return await currentSender({ code, templateId, content, props, name, type, level, options: targetOptions });
         }
-
         return { content, props, level, options: targetOptions };
       }
+      throw new Error(`未配置类型 ${type} 的消息发送器`);
     })(type);
     await models.record.create({ type, code, templateId, props, name, content: sendOptions });
   };
@@ -150,6 +179,253 @@ module.exports = fp(async (fastify, options) => {
       }
     },
     
+    // 统计相关服务
+    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: {
       list: async ({ filter = {}, perPage = 20, currentPage = 1 }) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kne/fastify-message",
-  "version": "1.0.6",
+  "version": "1.0.8",
   "description": "管理消息发送，支持sms消息，email消息等.",
   "main": "index.js",
   "scripts": {
@@ -59,6 +59,8 @@
     "sqlite3": "^6.0.1"
   },
   "dependencies": {
+    "@fastify/sse": "^0.4.0",
+    "dayjs": "^1.11.20",
     "fs-extra": "^11.3.0",
     "html-to-text": "^9.0.5",
     "lodash": "^4.17.21",