@zhin.js/plugin-rss 1.0.1 → 1.1.1

package/src/memory-store.ts

@@ -0,0 +1,88 @@
+/**
+ * In-memory RSS models used when no DatabaseHost is available.
+ *
+ * 模型表面与 `@zhin.js/plugin-runtime` 的 DatabaseHostModel 结构兼容：
+ * select 的 where 返回 PromiseLike（host 返回链式 Selection，memory 返回 Promise），
+ * 这样 plugin.ts 可以把 PluginDatabaseHost 直接当 RssMemoryDb 用。
+ */
+
+export type RssRow = Record<string, unknown>;
+
+export interface RssModel {
+  select: (...fields: string[]) => {
+    where: (query: Record<string, unknown>) => PromiseLike<RssRow[]>;
+    then: <TResult1 = RssRow[], TResult2 = never>(
+      onfulfilled?: ((value: RssRow[]) => TResult1 | PromiseLike<TResult1>) | null,
+      onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | null,
+    ) => Promise<TResult1 | TResult2>;
+  };
+  insert: (row: Record<string, unknown>) => Promise<unknown>;
+  delete: () => { where: (query: Record<string, unknown>) => Promise<unknown> };
+  update: (patch: Record<string, unknown>) => {
+    where: (query: Record<string, unknown>) => Promise<unknown>;
+  };
+}
+
+function createMemoryModel(): RssModel {
+  const rows: RssRow[] = [];
+  let nextId = 1;
+
+  function matches(row: Record<string, unknown>, query: Record<string, unknown>): boolean {
+    return Object.entries(query).every(([key, value]) => row[key] === value);
+  }
+
+  function all(): RssRow[] {
+    return rows.map((row) => ({ ...row }));
+  }
+
+  return {
+    select: () => {
+      const promise = Promise.resolve(all());
+      return {
+        where: async (query: Record<string, unknown>) =>
+          rows.filter((row) => matches(row, query)).map((row) => ({ ...row })),
+        then: (onfulfilled, onrejected) => promise.then(onfulfilled, onrejected),
+      };
+    },
+    insert: async (row: Record<string, unknown>) => {
+      const withId: RssRow = { id: String(nextId++), ...row };
+      rows.push(withId);
+      return { ...withId };
+    },
+    delete: () => ({
+      where: async (query: Record<string, unknown>) => {
+        for (let i = rows.length - 1; i >= 0; i -= 1) {
+          if (matches(rows[i]!, query)) rows.splice(i, 1);
+        }
+      },
+    }),
+    update: (patch: Record<string, unknown>) => ({
+      where: async (query: Record<string, unknown>) => {
+        for (const row of rows) {
+          if (matches(row, query)) Object.assign(row, patch);
+        }
+      },
+    }),
+  };
+}
+
+export interface RssMemoryDb {
+  models: {
+    get: (name: string) => RssModel | undefined;
+  };
+}
+
+export const RSS_SUBS_TABLE = 'rss_subscriptions';
+export const RSS_SEEN_TABLE = 'rss_seen_items';
+
+export function createInMemoryRssDb(): RssMemoryDb {
+  const models = new Map<string, RssModel>([
+    [RSS_SUBS_TABLE, createMemoryModel()],
+    [RSS_SEEN_TABLE, createMemoryModel()],
+  ]);
+  return {
+    models: {
+      get: (name: string) => models.get(name),
+    },
+  };
+}

package/src/poll.ts

@@ -0,0 +1,153 @@
+/**
+ * Feed poll helpers: detect new items; optional OutboundHost push to subscribers.
+ */
+import { fetchFeed, type FeedItem } from './feed.js';
+import { getRssSeen, getRssSubs } from './db-store.js';
+import type { RssRuntime } from './runtime.js';
+
+function ts(): string {
+  return new Date().toISOString();
+}
+
+export function formatNewItems(feedTitle: string, items: FeedItem[], maxItems: number): string {
+  const lines = [`${feedTitle} 有 ${items.length} 条新内容：`];
+  for (const item of items.slice(0, maxItems)) {
+    lines.push('');
+    lines.push(`${item.title}`);
+    if (item.summary) lines.push(item.summary);
+    if (item.link) lines.push(item.link);
+  }
+  if (items.length > maxItems) {
+    lines.push(`\n...还有 ${items.length - maxItems} 条，请查看源站`);
+  }
+  return lines.join('\n');
+}
+
+export async function markItemsSeen(runtime: RssRuntime, feedUrl: string, items: FeedItem[]): Promise<void> {
+  const Seen = getRssSeen(runtime.db);
+  if (!Seen) return;
+  for (const item of items) {
+    const dup = await Seen.select().where({ feed_url: feedUrl, item_guid: item.guid });
+    if (dup.length === 0) {
+      await Seen.insert({
+        feed_url: feedUrl,
+        item_guid: item.guid,
+        item_title: item.title,
+        seen_at: ts(),
+      });
+    }
+  }
+}
+
+export interface CheckResult {
+  readonly text: string;
+  readonly totalNew: number;
+  readonly pushed: number;
+}
+
+async function pushToSubscribers(runtime: RssRuntime, feedUrl: string, content: string): Promise<number> {
+  const push = runtime.outbound;
+  const Subs = getRssSubs(runtime.db);
+  if (!push || !Subs) return 0;
+  const subscribers = await Subs.select().where({ url: feedUrl });
+  let pushed = 0;
+  for (const sub of subscribers) {
+    const adapterName = String(sub.adapter_name ?? '');
+    const channelId = String(sub.channel_id ?? '');
+    if (!adapterName || !channelId) continue;
+    try {
+      await push({
+        adapterName,
+        endpointKey: String(sub.endpoint_id ?? adapterName),
+        channelType: String(sub.channel_type ?? 'private'),
+        channelId,
+        content,
+      });
+      pushed += 1;
+    } catch {
+      // OutboundHost already logs; continue other subscribers.
+    }
+  }
+  return pushed;
+}
+
+/**
+ * Check subscribed feeds for new items and mark them seen.
+ * When OutboundHost is wired, pushes formatted text to each subscriber channel.
+ */
+export async function checkSubscriptions(runtime: RssRuntime, options: {
+  urls: readonly string[];
+}): Promise<CheckResult> {
+  const Seen = getRssSeen(runtime.db);
+  const Subs = getRssSubs(runtime.db);
+  if (!Seen || !Subs) {
+    return { text: 'RSS 数据库尚未就绪', totalNew: 0, pushed: 0 };
+  }
+
+  const parts: string[] = [];
+  let totalNew = 0;
+  let pushed = 0;
+
+  for (const url of options.urls) {
+    try {
+      const { title, items } = await fetchFeed(url, runtime.config.timeout);
+      const seenRows = await Seen.select().where({ feed_url: url });
+      const seenGuids = new Set(seenRows.map((r) => String(r.item_guid ?? '')));
+      const newItems = items.filter((item) => item.guid && !seenGuids.has(item.guid));
+      if (newItems.length === 0) {
+        parts.push(`${title || url}: 无新内容`);
+        continue;
+      }
+      await markItemsSeen(runtime, url, newItems);
+      totalNew += newItems.length;
+      const body = formatNewItems(title || url, newItems, runtime.config.maxItems);
+      parts.push(body);
+      pushed += await pushToSubscribers(runtime, url, body);
+    } catch (e) {
+      parts.push(`${url}: 检查失败 — ${(e as Error).message}`);
+    }
+  }
+
+  if (parts.length === 0) return { text: '没有可检查的订阅', totalNew: 0, pushed: 0 };
+  const pushNote = runtime.outbound
+    ? (pushed > 0 ? `，已推送 ${pushed} 个会话` : '，无出站推送')
+    : '（未装配 OutboundHost，仅本地标记）';
+  const header = totalNew > 0
+    ? `检查完成，共 ${totalNew} 条新内容${pushNote}`
+    : '检查完成，暂无新内容';
+  return { text: `${header}\n\n${parts.join('\n\n')}`, totalNew, pushed };
+}
+
+/**
+ * Periodically clean seen records older than 7 days.
+ */
+export async function cleanOldSeen(runtime: RssRuntime): Promise<void> {
+  const Seen = getRssSeen(runtime.db);
+  if (!Seen) return;
+  try {
+    const cutoff = new Date();
+    cutoff.setDate(cutoff.getDate() - 7);
+    const cutoffStr = cutoff.toISOString();
+    const all = await Seen.select();
+    const expired = all.filter((r) => typeof r.seen_at === 'string' && r.seen_at < cutoffStr);
+    for (const row of expired) {
+      // 表结构没有 id 列，按业务键 (feed_url, item_guid) 删除。
+      await Seen.delete().where({ feed_url: row.feed_url, item_guid: row.item_guid });
+    }
+  } catch (e) {
+    // Cleanup failure must not break the main flow, but it must be visible.
+    console.warn(`[rss] cleanOldSeen failed: ${e instanceof Error ? e.message : String(e)}`);
+  }
+}
+
+/**
+ * Poll all unique feed URLs across subscriptions.
+ */
+export async function pollAllFeeds(runtime: RssRuntime): Promise<CheckResult> {
+  const Subs = getRssSubs(runtime.db);
+  if (!Subs) return { text: 'RSS 数据库尚未就绪', totalNew: 0, pushed: 0 };
+  const all = await Subs.select();
+  const urls = [...new Set(all.map((s) => String(s.url ?? '')).filter(Boolean))];
+  if (urls.length === 0) return { text: '暂无任何 RSS 订阅', totalNew: 0, pushed: 0 };
+  return checkSubscriptions(runtime, { urls });
+}

package/src/runtime.ts

@@ -0,0 +1,22 @@
+import { createToken } from 'zhin.js';
+import type { RssConfig } from './feed.js';
+import type { RssMemoryDb } from './memory-store.js';
+
+export type RssOutboundPush = (input: {
+  readonly adapterName: string;
+  readonly endpointKey: string;
+  readonly channelType: string;
+  readonly channelId: string;
+  readonly content: string;
+}) => Promise<void>;
+
+export interface RssRuntime {
+  readonly db: RssMemoryDb;
+  readonly config: Readonly<RssConfig>;
+  readonly outbound: RssOutboundPush | null;
+}
+
+export const rssRuntimeToken = createToken<RssRuntime>(
+  'zhin.rss.runtime',
+  'Owner-scoped RSS runtime',
+);