@rmdes/indiekit-endpoint-rss 1.0.0

package/index.js

@@ -0,0 +1,108 @@
+import express from "express";
+import { fileURLToPath } from "node:url";
+import path from "node:path";
+
+import { dashboardController } from "./lib/controllers/dashboard.js";
+import { feedsController } from "./lib/controllers/feeds.js";
+import { itemsController } from "./lib/controllers/items.js";
+import { statusController } from "./lib/controllers/status.js";
+import { startSync } from "./lib/sync.js";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+const protectedRouter = express.Router();
+const publicRouter = express.Router();
+
+const defaults = {
+  mountPath: "/rssapi",
+  syncInterval: 900_000, // 15 minutes
+  maxItemsPerFeed: 50,
+  fetchTimeout: 10_000,
+  maxConcurrentFetches: 3,
+};
+
+export default class RssEndpoint {
+  name = "RSS feed reader endpoint";
+
+  constructor(options = {}) {
+    this.options = { ...defaults, ...options };
+    this.mountPath = this.options.mountPath;
+  }
+
+  get localesDirectory() {
+    return path.join(__dirname, "locales");
+  }
+
+  get navigationItems() {
+    return {
+      href: this.options.mountPath,
+      text: "rss.title",
+      requiresDatabase: true,
+    };
+  }
+
+  get shortcutItems() {
+    return {
+      url: this.options.mountPath,
+      name: "rss.feeds",
+      iconName: "syndicate",
+      requiresDatabase: true,
+    };
+  }
+
+  /**
+   * Protected routes (require authentication)
+   * Admin dashboard and feed management
+   */
+  get routes() {
+    // Dashboard
+    protectedRouter.get("/", dashboardController.get);
+
+    // Manual sync trigger
+    protectedRouter.post("/sync", dashboardController.sync);
+
+    return protectedRouter;
+  }
+
+  /**
+   * Public routes (no authentication required)
+   * JSON API endpoints for frontend
+   */
+  get routesPublic() {
+    // Feeds API
+    publicRouter.get("/api/feeds", feedsController.list);
+    publicRouter.post("/api/feeds", express.json(), feedsController.add);
+    publicRouter.delete("/api/feeds/:id", feedsController.remove);
+    publicRouter.patch("/api/feeds/:id", express.json(), feedsController.toggle);
+
+    // Items API
+    publicRouter.get("/api/items", itemsController.list);
+    publicRouter.get("/api/items/:id", itemsController.get);
+
+    // Status API
+    publicRouter.get("/api/status", statusController.status);
+    publicRouter.post("/api/refresh", statusController.refresh);
+
+    return publicRouter;
+  }
+
+  init(Indiekit) {
+    Indiekit.addEndpoint(this);
+
+    // Add MongoDB collections
+    Indiekit.addCollection("rssFeeds");
+    Indiekit.addCollection("rssItems");
+
+    // Store config in application for controller access
+    Indiekit.config.application.rssConfig = this.options;
+    Indiekit.config.application.rssEndpoint = this.mountPath;
+
+    // Store database getter for controller access
+    Indiekit.config.application.getRssDb = () => Indiekit.database;
+
+    // Start background sync if database is available
+    if (Indiekit.config.application.mongodbUrl) {
+      startSync(Indiekit, this.options);
+    }
+  }
+}

package/lib/controllers/dashboard.js

@@ -0,0 +1,106 @@
+import { getSyncState, runSync } from "../sync.js";
+import { formatFeed, formatItem } from "../utils.js";
+
+export const dashboardController = {
+  /**
+   * Render admin dashboard
+   * GET /
+   */
+  async get(request, response, next) {
+    try {
+      const { rssConfig, rssEndpoint } = request.app.locals.application;
+
+      if (!rssConfig) {
+        return response.status(500).render("rss", {
+          title: response.locals.__("rss.title"),
+          error: { message: response.locals.__("rss.error.noConfig") },
+        });
+      }
+
+      const db = request.app.locals.application.getRssDb?.();
+      if (!db) {
+        return response.render("rss", {
+          title: response.locals.__("rss.title"),
+          error: { message: response.locals.__("rss.error.noDatabase") },
+        });
+      }
+
+      const feedsCollection = db.collection("rssFeeds");
+      const itemsCollection = db.collection("rssItems");
+
+      // Get feeds and recent items
+      const [feeds, recentItems, totalItems] = await Promise.all([
+        feedsCollection.find({}).sort({ addedAt: -1 }).toArray(),
+        itemsCollection
+          .find({})
+          .sort({ pubDate: -1 })
+          .limit(10)
+          .toArray(),
+        itemsCollection.countDocuments({}),
+      ]);
+
+      const syncState = getSyncState();
+
+      response.render("rss", {
+        title: response.locals.__("rss.title"),
+        feeds: feeds.map(formatFeed),
+        recentItems: recentItems.map((item) => formatItem(item)),
+        totalFeeds: feeds.length,
+        totalItems,
+        syncState: {
+          syncing: syncState.syncing,
+          lastSync: syncState.lastSync?.toISOString(),
+          lastError: syncState.lastError,
+        },
+        publicUrl: rssEndpoint,
+      });
+    } catch (error) {
+      next(error);
+    }
+  },
+
+  /**
+   * Trigger manual sync
+   * POST /sync
+   */
+  async sync(request, response) {
+    try {
+      const Indiekit = request.app.locals.indiekit;
+      const { rssConfig } = request.app.locals.application;
+
+      if (!Indiekit || !rssConfig) {
+        return response.status(500).json({
+          error: response.locals.__("rss.error.noConfig"),
+        });
+      }
+
+      const syncState = getSyncState();
+      if (syncState.syncing) {
+        return response.status(409).json({
+          error: "Sync already in progress",
+          syncing: true,
+        });
+      }
+
+      // Start sync and wait for result
+      const result = await runSync(Indiekit, rssConfig);
+
+      if (result.error) {
+        return response.status(500).json({
+          success: false,
+          error: result.error,
+        });
+      }
+
+      response.json({
+        success: true,
+        message: response.locals.__("rss.success.syncComplete"),
+        feedsProcessed: result.feedsProcessed,
+        itemsAdded: result.itemsAdded,
+      });
+    } catch (error) {
+      console.error("[RSS] Sync error:", error.message);
+      response.status(500).json({ error: error.message });
+    }
+  },
+};

package/lib/controllers/feeds.js

@@ -0,0 +1,198 @@
+import { ObjectId } from "mongodb";
+import { RssClient } from "../rss-client.js";
+import { formatFeed, isValidUrl, normalizeUrl } from "../utils.js";
+
+export const feedsController = {
+  /**
+   * List all feeds
+   * GET /api/feeds
+   */
+  async list(request, response) {
+    try {
+      const db = request.app.locals.application.getRssDb?.();
+      if (!db) {
+        return response.status(500).json({ error: "Database not available" });
+      }
+
+      const feedsCollection = db.collection("rssFeeds");
+      const feeds = await feedsCollection
+        .find({})
+        .sort({ addedAt: -1 })
+        .toArray();
+
+      response.json({
+        feeds: feeds.map(formatFeed),
+        total: feeds.length,
+      });
+    } catch (error) {
+      console.error("[RSS] Error listing feeds:", error.message);
+      response.status(500).json({ error: error.message });
+    }
+  },
+
+  /**
+   * Add a new feed
+   * POST /api/feeds
+   * Body: { url: string }
+   */
+  async add(request, response) {
+    try {
+      const { url } = request.body;
+
+      if (!url || !isValidUrl(url)) {
+        return response.status(400).json({
+          error: response.locals.__("rss.error.invalidUrl"),
+        });
+      }
+
+      const normalizedUrl = normalizeUrl(url);
+      const db = request.app.locals.application.getRssDb?.();
+      if (!db) {
+        return response.status(500).json({ error: "Database not available" });
+      }
+
+      const feedsCollection = db.collection("rssFeeds");
+
+      // Check if feed already exists
+      const existing = await feedsCollection.findOne({ url: normalizedUrl });
+      if (existing) {
+        return response.status(409).json({
+          error: response.locals.__("rss.error.feedExists"),
+        });
+      }
+
+      // Fetch feed to validate and get metadata
+      const { rssConfig } = request.app.locals.application;
+      const client = new RssClient({
+        timeout: rssConfig?.fetchTimeout || 10_000,
+      });
+
+      let feedMeta;
+      try {
+        const result = await client.fetchFeed(normalizedUrl);
+        feedMeta = result.feed;
+      } catch (error) {
+        return response.status(400).json({
+          error: `${response.locals.__("rss.error.fetchFailed")}: ${error.message}`,
+        });
+      }
+
+      // Insert feed
+      const feed = {
+        url: normalizedUrl,
+        title: feedMeta.title,
+        siteUrl: feedMeta.siteUrl,
+        description: feedMeta.description,
+        imageUrl: feedMeta.imageUrl,
+        enabled: true,
+        addedAt: new Date(),
+        lastFetchedAt: null,
+        lastError: null,
+        itemCount: 0,
+      };
+
+      const result = await feedsCollection.insertOne(feed);
+      feed._id = result.insertedId;
+
+      response.status(201).json({
+        message: response.locals.__("rss.success.feedAdded"),
+        feed: formatFeed(feed),
+      });
+    } catch (error) {
+      console.error("[RSS] Error adding feed:", error.message);
+      response.status(500).json({ error: error.message });
+    }
+  },
+
+  /**
+   * Remove a feed
+   * DELETE /api/feeds/:id
+   */
+  async remove(request, response) {
+    try {
+      const { id } = request.params;
+
+      if (!ObjectId.isValid(id)) {
+        return response.status(400).json({ error: "Invalid feed ID" });
+      }
+
+      const db = request.app.locals.application.getRssDb?.();
+      if (!db) {
+        return response.status(500).json({ error: "Database not available" });
+      }
+
+      const feedsCollection = db.collection("rssFeeds");
+      const itemsCollection = db.collection("rssItems");
+      const feedId = new ObjectId(id);
+
+      // Check if feed exists
+      const feed = await feedsCollection.findOne({ _id: feedId });
+      if (!feed) {
+        return response.status(404).json({
+          error: response.locals.__("rss.error.feedNotFound"),
+        });
+      }
+
+      // Delete feed and its items
+      await itemsCollection.deleteMany({ feedId });
+      await feedsCollection.deleteOne({ _id: feedId });
+
+      response.json({
+        message: response.locals.__("rss.success.feedRemoved"),
+      });
+    } catch (error) {
+      console.error("[RSS] Error removing feed:", error.message);
+      response.status(500).json({ error: error.message });
+    }
+  },
+
+  /**
+   * Toggle feed enabled/disabled
+   * PATCH /api/feeds/:id
+   * Body: { enabled: boolean }
+   */
+  async toggle(request, response) {
+    try {
+      const { id } = request.params;
+      const { enabled } = request.body;
+
+      if (!ObjectId.isValid(id)) {
+        return response.status(400).json({ error: "Invalid feed ID" });
+      }
+
+      if (typeof enabled !== "boolean") {
+        return response.status(400).json({ error: "enabled must be boolean" });
+      }
+
+      const db = request.app.locals.application.getRssDb?.();
+      if (!db) {
+        return response.status(500).json({ error: "Database not available" });
+      }
+
+      const feedsCollection = db.collection("rssFeeds");
+      const feedId = new ObjectId(id);
+
+      const result = await feedsCollection.findOneAndUpdate(
+        { _id: feedId },
+        { $set: { enabled } },
+        { returnDocument: "after" }
+      );
+
+      if (!result) {
+        return response.status(404).json({
+          error: response.locals.__("rss.error.feedNotFound"),
+        });
+      }
+
+      response.json({
+        message: enabled
+          ? response.locals.__("rss.success.feedEnabled")
+          : response.locals.__("rss.success.feedDisabled"),
+        feed: formatFeed(result),
+      });
+    } catch (error) {
+      console.error("[RSS] Error toggling feed:", error.message);
+      response.status(500).json({ error: error.message });
+    }
+  },
+};

package/lib/controllers/items.js

@@ -0,0 +1,95 @@
+import { ObjectId } from "mongodb";
+import { formatItem } from "../utils.js";
+
+export const itemsController = {
+  /**
+   * List feed items with pagination
+   * GET /api/items
+   * Query: page, limit, feedId, includeContent
+   */
+  async list(request, response) {
+    try {
+      const db = request.app.locals.application.getRssDb?.();
+      if (!db) {
+        return response.status(500).json({ error: "Database not available" });
+      }
+
+      const page = Math.max(1, parseInt(request.query.page) || 1);
+      const limit = Math.min(100, Math.max(1, parseInt(request.query.limit) || 20));
+      const feedId = request.query.feedId;
+      const includeContent = request.query.includeContent === "true";
+      const skip = (page - 1) * limit;
+
+      const itemsCollection = db.collection("rssItems");
+
+      // Build query
+      const query = {};
+      if (feedId && ObjectId.isValid(feedId)) {
+        query.feedId = new ObjectId(feedId);
+      }
+
+      // Get total count
+      const total = await itemsCollection.countDocuments(query);
+
+      // Get items
+      const items = await itemsCollection
+        .find(query)
+        .sort({ pubDate: -1 })
+        .skip(skip)
+        .limit(limit)
+        .toArray();
+
+      const totalPages = Math.ceil(total / limit);
+
+      response.json({
+        items: items.map((item) =>
+          formatItem(item, { includeContent })
+        ),
+        pagination: {
+          page,
+          limit,
+          total,
+          totalPages,
+          hasNext: page < totalPages,
+          hasPrev: page > 1,
+        },
+      });
+    } catch (error) {
+      console.error("[RSS] Error listing items:", error.message);
+      response.status(500).json({ error: error.message });
+    }
+  },
+
+  /**
+   * Get a single item by ID
+   * GET /api/items/:id
+   */
+  async get(request, response) {
+    try {
+      const { id } = request.params;
+
+      if (!ObjectId.isValid(id)) {
+        return response.status(400).json({ error: "Invalid item ID" });
+      }
+
+      const db = request.app.locals.application.getRssDb?.();
+      if (!db) {
+        return response.status(500).json({ error: "Database not available" });
+      }
+
+      const itemsCollection = db.collection("rssItems");
+      const item = await itemsCollection.findOne({ _id: new ObjectId(id) });
+
+      if (!item) {
+        return response.status(404).json({ error: "Item not found" });
+      }
+
+      response.json({
+        item: formatItem(item, { includeContent: true }),
+      });
+    } catch (error) {
+      console.error("[RSS] Error getting item:", error.message);
+      response.status(500).json({ error: error.message });
+    }
+  },
+};

package/lib/controllers/status.js

@@ -0,0 +1,90 @@
+import { getSyncState, runSync } from "../sync.js";
+
+export const statusController = {
+  /**
+   * Get sync status
+   * GET /api/status
+   */
+  async status(request, response) {
+    try {
+      const db = request.app.locals.application.getRssDb?.();
+      const syncState = getSyncState();
+      const { rssConfig } = request.app.locals.application;
+
+      let feedsCount = 0;
+      let itemsCount = 0;
+      let enabledFeedsCount = 0;
+
+      if (db) {
+        const feedsCollection = db.collection("rssFeeds");
+        const itemsCollection = db.collection("rssItems");
+
+        feedsCount = await feedsCollection.countDocuments({});
+        enabledFeedsCount = await feedsCollection.countDocuments({ enabled: true });
+        itemsCount = await itemsCollection.countDocuments({});
+      }
+
+      const syncIntervalMs = rssConfig?.syncInterval || 900_000;
+      const nextSync = syncState.lastSync
+        ? new Date(syncState.lastSync.getTime() + syncIntervalMs)
+        : null;
+
+      response.json({
+        status: syncState.syncing ? "syncing" : "idle",
+        lastSync: syncState.lastSync?.toISOString() || null,
+        nextSync: nextSync?.toISOString() || null,
+        lastError: syncState.lastError,
+        stats: {
+          feedsCount,
+          enabledFeedsCount,
+          itemsCount,
+          lastFeedsProcessed: syncState.feedsProcessed,
+          lastItemsAdded: syncState.itemsAdded,
+        },
+        config: {
+          syncInterval: syncIntervalMs,
+          maxItemsPerFeed: rssConfig?.maxItemsPerFeed || 50,
+        },
+      });
+    } catch (error) {
+      console.error("[RSS] Error getting status:", error.message);
+      response.status(500).json({ error: error.message });
+    }
+  },
+
+  /**
+   * Trigger manual sync
+   * POST /api/refresh
+   */
+  async refresh(request, response) {
+    try {
+      const Indiekit = request.app.locals.indiekit;
+      const { rssConfig } = request.app.locals.application;
+
+      if (!Indiekit || !rssConfig) {
+        return response.status(500).json({ error: "Plugin not configured" });
+      }
+
+      const syncState = getSyncState();
+      if (syncState.syncing) {
+        return response.status(409).json({
+          error: "Sync already in progress",
+          status: "syncing",
+        });
+      }
+
+      // Run sync asynchronously
+      runSync(Indiekit, rssConfig).catch((err) => {
+        console.error("[RSS] Manual sync error:", err.message);
+      });
+
+      response.json({
+        message: response.locals.__("rss.syncing"),
+        status: "started",
+      });
+    } catch (error) {
+      console.error("[RSS] Error triggering refresh:", error.message);
+      response.status(500).json({ error: error.message });
+    }
+  },
+};