@anyul/koishi-plugin-rss 5.2.3 → 5.2.4

package/lib/core/notification-queue-store.d.ts

@@ -0,0 +1,19 @@
+import { Context } from 'koishi';
+import { NewQueueTask, QueueCreateResult, QueueStats, QueueTask, QueueTaskContent, QueueTaskIdentity } from './notification-queue-types';
+export declare const RSS_NOTIFICATION_QUEUE_TABLE = "rss_notification_queue";
+export declare class NotificationQueueStore {
+    private ctx;
+    private batchSize;
+    constructor(ctx: Context, batchSize: number);
+    findTaskByIdentity(identity: QueueTaskIdentity): Promise<QueueTask | null>;
+    createTask(task: NewQueueTask): Promise<QueueCreateResult>;
+    getPendingTasks(): Promise<QueueTask[]>;
+    markTaskSuccess(taskId: number): Promise<void>;
+    markTaskRetry(task: QueueTask, nextTime: Date, reason: string): Promise<void>;
+    updateTaskForDowngrade(task: QueueTask, content: QueueTaskContent): Promise<void>;
+    markTaskFailed(taskId: number, reason: string): Promise<void>;
+    recoverRetryTasksWithoutNextRetryTime(): Promise<number>;
+    getStats(): Promise<QueueStats>;
+    retryFailedTasks(taskId?: number): Promise<number>;
+    cleanupSuccessTasks(olderThanHours?: number): Promise<number>;
+}

package/lib/core/notification-queue-store.js

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotificationQueueStore = exports.RSS_NOTIFICATION_QUEUE_TABLE = void 0;
+exports.RSS_NOTIFICATION_QUEUE_TABLE = 'rss_notification_queue';
+class NotificationQueueStore {
+    ctx;
+    batchSize;
+    constructor(ctx, batchSize) {
+        this.ctx = ctx;
+        this.batchSize = batchSize;
+    }
+    async findTaskByIdentity(identity) {
+        const tasks = await this.ctx.database.get(exports.RSS_NOTIFICATION_QUEUE_TABLE, identity);
+        if (!tasks.length) {
+            return null;
+        }
+        return [...tasks].sort((a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime())[0];
+    }
+    async createTask(task) {
+        const existingTask = await this.findTaskByIdentity({
+            subscribeId: task.subscribeId,
+            uid: task.uid,
+            guildId: task.guildId,
+            platform: task.platform,
+        });
+        if (existingTask) {
+            return {
+                task: existingTask,
+                created: false,
+            };
+        }
+        const queueTask = {
+            ...task,
+            status: 'PENDING',
+            retryCount: 0,
+            createdAt: new Date(),
+            updatedAt: new Date(),
+        };
+        const createdTask = await this.ctx.database.create(exports.RSS_NOTIFICATION_QUEUE_TABLE, queueTask);
+        return {
+            task: {
+                ...queueTask,
+                ...createdTask,
+            },
+            created: true,
+        };
+    }
+    async getPendingTasks() {
+        const now = new Date();
+        const pendingTasks = await this.ctx.database.get(exports.RSS_NOTIFICATION_QUEUE_TABLE, { status: 'PENDING' }, { limit: this.batchSize });
+        const retryTasks = await this.ctx.database.get(exports.RSS_NOTIFICATION_QUEUE_TABLE, { status: 'RETRY' }, { limit: this.batchSize });
+        const readyRetryTasks = retryTasks.filter(task => task.nextRetryTime && new Date(task.nextRetryTime) <= now);
+        return [...pendingTasks, ...readyRetryTasks]
+            .sort((a, b) => new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime())
+            .slice(0, this.batchSize);
+    }
+    async markTaskSuccess(taskId) {
+        await this.ctx.database.set(exports.RSS_NOTIFICATION_QUEUE_TABLE, { id: taskId }, {
+            status: 'SUCCESS',
+            nextRetryTime: null,
+            failReason: null,
+            updatedAt: new Date(),
+        });
+    }
+    async markTaskRetry(task, nextTime, reason) {
+        await this.ctx.database.set(exports.RSS_NOTIFICATION_QUEUE_TABLE, { id: task.id }, {
+            status: 'RETRY',
+            nextRetryTime: nextTime,
+            retryCount: (task.retryCount || 0) + 1,
+            failReason: reason,
+            updatedAt: new Date(),
+        });
+    }
+    async updateTaskForDowngrade(task, content) {
+        await this.ctx.database.set(exports.RSS_NOTIFICATION_QUEUE_TABLE, { id: task.id }, {
+            content,
+            status: 'RETRY',
+            nextRetryTime: new Date(),
+            retryCount: (task.retryCount || 0) + 1,
+            failReason: null,
+            updatedAt: new Date(),
+        });
+    }
+    async markTaskFailed(taskId, reason) {
+        await this.ctx.database.set(exports.RSS_NOTIFICATION_QUEUE_TABLE, { id: taskId }, {
+            status: 'FAILED',
+            nextRetryTime: null,
+            failReason: reason,
+            updatedAt: new Date(),
+        });
+    }
+    async recoverRetryTasksWithoutNextRetryTime() {
+        const retryTasks = await this.ctx.database.get(exports.RSS_NOTIFICATION_QUEUE_TABLE, { status: 'RETRY' }, { limit: this.batchSize });
+        const invalidTasks = retryTasks.filter(task => !task.nextRetryTime);
+        for (const task of invalidTasks) {
+            await this.ctx.database.set(exports.RSS_NOTIFICATION_QUEUE_TABLE, { id: task.id }, {
+                status: 'RETRY',
+                nextRetryTime: new Date(),
+                updatedAt: new Date(),
+            });
+        }
+        return invalidTasks.length;
+    }
+    async getStats() {
+        const allTasks = await this.ctx.database.get(exports.RSS_NOTIFICATION_QUEUE_TABLE, {});
+        return {
+            pending: allTasks.filter((task) => task.status === 'PENDING').length,
+            retry: allTasks.filter((task) => task.status === 'RETRY').length,
+            failed: allTasks.filter((task) => task.status === 'FAILED').length,
+            success: allTasks.filter((task) => task.status === 'SUCCESS').length,
+        };
+    }
+    async retryFailedTasks(taskId) {
+        const where = taskId ? { id: taskId } : { status: 'FAILED' };
+        const tasks = await this.ctx.database.get(exports.RSS_NOTIFICATION_QUEUE_TABLE, where);
+        const failedTasks = tasks.filter(task => task.status === 'FAILED');
+        for (const task of failedTasks) {
+            await this.ctx.database.set(exports.RSS_NOTIFICATION_QUEUE_TABLE, { id: task.id }, {
+                status: 'PENDING',
+                retryCount: 0,
+                nextRetryTime: null,
+                failReason: null,
+                updatedAt: new Date(),
+            });
+        }
+        return failedTasks.length;
+    }
+    async cleanupSuccessTasks(olderThanHours = 24) {
+        const cutoffTime = new Date(Date.now() - olderThanHours * 60 * 60 * 1000);
+        const tasks = await this.ctx.database.get(exports.RSS_NOTIFICATION_QUEUE_TABLE, { status: 'SUCCESS', updatedAt: { $lt: cutoffTime } });
+        for (const task of tasks) {
+            await this.ctx.database.remove(exports.RSS_NOTIFICATION_QUEUE_TABLE, { id: task.id });
+        }
+        return tasks.length;
+    }
+}
+exports.NotificationQueueStore = NotificationQueueStore;

package/lib/core/notification-queue-types.d.ts

@@ -0,0 +1,49 @@
+export type QueueStatus = 'PENDING' | 'RETRY' | 'FAILED' | 'SUCCESS';
+/**
+ * 队列任务内容
+ */
+export interface QueueTaskContent {
+    message: string;
+    originalItem?: any;
+    isDowngraded?: boolean;
+    title?: string;
+    description?: string;
+    link?: string;
+    pubDate?: Date;
+    imageUrl?: string;
+}
+/**
+ * 队列任务接口
+ */
+export interface QueueTask {
+    id?: number;
+    subscribeId: string;
+    rssId: string;
+    uid: string;
+    guildId: string;
+    platform: string;
+    content: QueueTaskContent;
+    status: QueueStatus;
+    retryCount: number;
+    nextRetryTime?: Date;
+    createdAt: Date;
+    updatedAt: Date;
+    failReason?: string | null;
+}
+export type NewQueueTask = Omit<QueueTask, 'id' | 'status' | 'retryCount' | 'createdAt' | 'updatedAt'>;
+export interface QueueTaskIdentity {
+    subscribeId: string;
+    uid: string;
+    guildId: string;
+    platform: string;
+}
+export interface QueueCreateResult {
+    task: QueueTask;
+    created: boolean;
+}
+export interface QueueStats {
+    pending: number;
+    retry: number;
+    failed: number;
+    success: number;
+}

package/lib/core/notification-queue-types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/core/notification-queue.d.ts

@@ -1,41 +1,7 @@
-/**
- * 消息发送队列管理器
- * 实现可靠的消息推送，支持重试、降级和错误处理
- */
 import { Context } from 'koishi';
 import { Config } from '../types';
-export type QueueStatus = 'PENDING' | 'RETRY' | 'FAILED' | 'SUCCESS';
-/**
- * 队列任务接口
- */
-export interface QueueTask {
-    id?: number;
-    subscribeId: string;
-    rssId: string;
-    uid: string;
-    guildId: string;
-    platform: string;
-    content: QueueTaskContent;
-    status: QueueStatus;
-    retryCount: number;
-    nextRetryTime?: Date;
-    createdAt: Date;
-    updatedAt: Date;
-    failReason?: string;
-}
-/**
- * 队列任务内容
- */
-export interface QueueTaskContent {
-    message: string;
-    originalItem?: any;
-    isDowngraded?: boolean;
-    title?: string;
-    description?: string;
-    link?: string;
-    pubDate?: Date;
-    imageUrl?: string;
-}
+import { NewQueueTask, QueueStats, QueueTask } from './notification-queue-types';
+export type { QueueStatus, QueueTask, QueueTaskContent, QueueTaskIdentity, QueueCreateResult } from './notification-queue-types';
 /**
  * 消息发送队列管理器
  */
@@ -43,8 +9,12 @@ export declare class NotificationQueueManager {
     private ctx;
     private config;
     private processing;
-    private maxRetries;
+    private recovered;
     private batchSize;
+    private maxRetries;
+    private cleanupHours;
+    private store;
+    private sender;
     private backoffDelays;
     constructor(ctx: Context, config: Config);
     private buildTaskLogContext;
@@ -52,23 +22,17 @@ export declare class NotificationQueueManager {
     /**
      * 添加任务到队列
      */
-    addTask(task: Omit<QueueTask, 'id' | 'status' | 'retryCount' | 'createdAt' | 'updatedAt'>): Promise<QueueTask>;
+    addTask(task: NewQueueTask): Promise<QueueTask>;
+    isProcessing(): boolean;
+    private ensureRecovered;
     /**
      * 处理队列中的任务
      */
     processQueue(): Promise<void>;
-    /**
-     * 获取待处理任务
-     */
-    private getPendingTasks;
     /**
      * 处理单个任务
      */
     private processTask;
-    /**
-     * 发送消息（带降级机制）
-     */
-    private sendMessage;
     /**
      * 处理发送错误
      */
@@ -81,35 +45,10 @@ export declare class NotificationQueueManager {
      * 降级消息（移除媒体元素）
      */
     private downgradeMessage;
-    /**
-     * 标记任务为成功
-     */
-    private markTaskSuccess;
-    /**
-     * 标记任务为重试
-     */
-    private markTaskRetry;
-    /**
-     * 更新任务为降级重试
-     */
-    private updateTaskForDowngrade;
-    /**
-     * 标记任务为失败
-     */
-    private markTaskFailed;
-    /**
-     * 缓存成功发送的消息
-     */
-    private cacheMessage;
     /**
      * 获取队列统计信息
      */
-    getStats(): Promise<{
-        pending: number;
-        retry: number;
-        failed: number;
-        success: number;
-    }>;
+    getStats(): Promise<QueueStats>;
     /**
      * 重试失败的任务
      */