@rmdes/indiekit-endpoint-rss 1.0.2 → 1.0.4

package/index.js

@@ -61,6 +61,9 @@ export default class RssEndpoint {
     // Manual sync trigger
     protectedRouter.post("/sync", dashboardController.sync);
 
+    // Clear items and re-sync
+    protectedRouter.post("/clear-resync", dashboardController.clearResync);
+
     // Feed management (protected - requires auth)
     protectedRouter.post("/api/feeds", express.json(), feedsController.add);
     protectedRouter.delete("/api/feeds/:id", feedsController.remove);

package/lib/controllers/dashboard.js

@@ -59,6 +59,59 @@ export const dashboardController = {
     }
   },
 
+  /**
+   * Clear all items and re-sync
+   * POST /clear-resync
+   */
+  async clearResync(request, response) {
+    try {
+      const { rssConfig, getRssDb } = request.app.locals.application;
+
+      if (!rssConfig) {
+        return response.status(500).json({
+          error: response.locals.__("rss.error.noConfig"),
+        });
+      }
+
+      const db = getRssDb?.();
+      if (!db) {
+        return response.status(500).json({
+          error: response.locals.__("rss.error.noDatabase"),
+        });
+      }
+
+      // Drop all items
+      const itemsCollection = db.collection("rssItems");
+      const deleteResult = await itemsCollection.deleteMany({});
+      console.log(`[RSS] Cleared ${deleteResult.deletedCount} items`);
+
+      // Reset feed item counts
+      const feedsCollection = db.collection("rssFeeds");
+      await feedsCollection.updateMany({}, { $set: { itemCount: 0 } });
+
+      // Trigger sync
+      const result = await runSync(db, rssConfig);
+
+      if (result.error) {
+        return response.status(500).json({
+          success: false,
+          error: result.error,
+        });
+      }
+
+      response.json({
+        success: true,
+        message: response.locals.__("rss.success.clearResync"),
+        itemsCleared: deleteResult.deletedCount,
+        feedsProcessed: result.feedsProcessed,
+        itemsAdded: result.itemsAdded,
+      });
+    } catch (error) {
+      console.error("[RSS] Clear & re-sync error:", error.message);
+      response.status(500).json({ error: error.message });
+    }
+  },
+
   /**
    * Trigger manual sync
    * POST /sync

package/lib/rss-client.js

@@ -158,26 +158,35 @@ export class RssClient {
         !cat.startsWith("user/")
       );
 
+      // For aggregators like FreshRSS, use origin info for the real source
+      const originTitle = item.origin?.title || null;
+      const originUrl = item.origin?.htmlUrl || null;
+
+      // Extract a meaningful description/summary
+      const description = this.extractDescription(content, item.summary);
+
       return {
         guid: item["frss:id"] || item.id || item.guid || link,
         title: item.title || "Untitled",
         link,
-        description: item.summary?.content ||
-                    (typeof item.summary === "string" ? item.summary : "") ||
-                    "",
+        description,
         content,
-        author: item.author || item.origin?.title || null,
+        // For author, prefer the actual author field, fall back to origin title only if no author
+        author: item.author || null,
         pubDate,
-        imageUrl: this.extractJsonItemImage(item),
+        imageUrl: this.extractJsonItemImage(item, content),
         categories,
         enclosure: item.enclosure || null,
-        // Preserve FreshRSS-specific metadata
+        // Preserve FreshRSS-specific metadata - use origin for real source feed
         origin: item.origin ? {
           streamId: item.origin.streamId,
           title: item.origin.title,
           htmlUrl: item.origin.htmlUrl,
           feedUrl: item.origin.feedUrl,
         } : null,
+        // Denormalized fields for easier display
+        sourceTitle: originTitle,
+        sourceUrl: originUrl,
       };
     });
 
@@ -226,30 +235,71 @@ export class RssClient {
   /**
    * Extract image from JSON feed item
    * @param {Object} item - JSON item
+   * @param {string} content - Pre-extracted content string
    * @returns {string|null}
    */
-  extractJsonItemImage(item) {
+  extractJsonItemImage(item, content = "") {
     // Direct image property
     if (item.image) return item.image;
 
-    // Media content
+    // Media content (various formats)
     if (item.media?.$?.url) return item.media.$.url;
+    if (item["media:content"]?.["$"]?.url) return item["media:content"]["$"].url;
+    if (item["media:thumbnail"]?.["$"]?.url) return item["media:thumbnail"]["$"].url;
 
     // Enclosure
     if (item.enclosure?.href && this.isImageUrl(item.enclosure.href)) {
       return item.enclosure.href;
     }
+    if (item.enclosure?.url && this.isImageUrl(item.enclosure.url)) {
+      return item.enclosure.url;
+    }
 
-    // Extract from content
-    const content = item.content?.content || item.content || item.summary?.content || "";
-    if (typeof content === "string") {
+    // Extract from content HTML
+    if (typeof content === "string" && content.length > 0) {
       const imgMatch = content.match(/<img[^>]+src=["']([^"']+)["']/i);
       if (imgMatch) return imgMatch[1];
     }
 
+    // Try item's own content fields
+    const itemContent = item.content?.content || item.content || item.summary?.content || "";
+    if (typeof itemContent === "string" && itemContent.length > 0) {
+      const imgMatch = itemContent.match(/<img[^>]+src=["']([^"']+)["']/i);
+      if (imgMatch) return imgMatch[1];
+    }
+
     return null;
   }
 
+  /**
+   * Extract a clean description/summary from content
+   * @param {string} content - HTML content
+   * @param {Object|string} summary - Summary object or string
+   * @returns {string}
+   */
+  extractDescription(content, summary) {
+    // First try the summary
+    let desc = "";
+    if (typeof summary === "string") {
+      desc = summary;
+    } else if (summary?.content) {
+      desc = summary.content;
+    }
+
+    // If no summary, extract from content
+    if (!desc && typeof content === "string" && content.length > 0) {
+      // Strip HTML tags and get first 300 chars
+      desc = content
+        .replace(/<[^>]+>/g, " ")  // Remove HTML tags
+        .replace(/\s+/g, " ")       // Normalize whitespace
+        .trim()
+        .slice(0, 300);
+      if (content.length > 300) desc += "...";
+    }
+
+    return desc;
+  }
+
   /**
    * Extract feed metadata
    * @param {Object} parsed - Parsed feed object

package/lib/utils.js

@@ -99,6 +99,14 @@ function isImageType(type) {
 export function formatItem(item, options = {}) {
   const { includeContent = false, descriptionLength = 200 } = options;
 
+  // Handle description - use item.description if available, otherwise generate from content
+  let description = item.description;
+  if (!description && item.content) {
+    description = truncateText(item.content, descriptionLength);
+  } else if (description) {
+    description = truncateText(description, descriptionLength);
+  }
+
   const formatted = {
     id: item._id?.toString(),
     feedId: item.feedId?.toString(),
@@ -106,14 +114,22 @@ export function formatItem(item, options = {}) {
     guid: item.guid,
     title: item.title,
     link: item.link,
-    description: truncateText(item.description, descriptionLength),
+    description: description || "",
     author: item.author,
     pubDate: item.pubDate?.toISOString(),
     imageUrl: item.imageUrl,
     categories: item.categories || [],
     fetchedAt: item.fetchedAt?.toISOString(),
+    // Source info for aggregators (like FreshRSS) - represents the original feed
+    sourceTitle: item.sourceTitle || null,
+    sourceUrl: item.sourceUrl || null,
   };
 
+  // Include origin object if present (for aggregator metadata)
+  if (item.origin) {
+    formatted.origin = item.origin;
+  }
+
   if (includeContent) {
     formatted.content = sanitizeHtml(item.content);
   }

package/locales/en.json

@@ -8,6 +8,7 @@
     "enableFeed": "Enable",
     "disableFeed": "Disable",
     "syncNow": "Sync Now",
+    "clearResync": "Clear & Re-sync",
     "syncing": "Syncing...",
     "lastSynced": "Last synced",
     "noFeeds": "No feeds configured. Add a feed URL to get started.",
@@ -40,7 +41,8 @@
       "feedRemoved": "Feed removed",
       "feedEnabled": "Feed enabled",
       "feedDisabled": "Feed disabled",
-      "syncComplete": "Sync complete"
+      "syncComplete": "Sync complete",
+      "clearResync": "Items cleared and re-synced"
     },
     "widget": {
       "description": "View aggregated RSS feeds on the public page",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rmdes/indiekit-endpoint-rss",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "RSS feed reader endpoint for Indiekit. Aggregates multiple feeds, caches in MongoDB, displays on frontend.",
   "keywords": [
     "indiekit",

package/views/rss.njk

@@ -284,13 +284,22 @@
         <span class="rss-feed-error">{{ syncState.lastError }}</span>
         {% endif %}
       </div>
-      <form action="{{ publicUrl }}/sync" method="post">
-        {{ button({
-          type: "submit",
-          text: __("rss.syncNow"),
-          disabled: syncState.syncing
-        }) }}
-      </form>
+      <div style="display: flex; gap: 0.5rem;">
+        <form action="{{ publicUrl }}/sync" method="post" style="margin: 0;">
+          {{ button({
+            type: "submit",
+            text: __("rss.syncNow"),
+            disabled: syncState.syncing
+          }) }}
+        </form>
+        <form action="{{ publicUrl }}/clear-resync" method="post" style="margin: 0;" id="clear-resync-form">
+          {{ button({
+            type: "submit",
+            text: __("rss.clearResync"),
+            disabled: syncState.syncing
+          }) }}
+        </form>
+      </div>
     </div>
 
     {# Stats #}
@@ -471,6 +480,45 @@
       });
     });
 
+    // Handle clear & re-sync
+    document.getElementById('clear-resync-form')?.addEventListener('submit', async (e) => {
+      e.preventDefault();
+      if (!confirm('This will delete all cached items and re-fetch them from feeds. Continue?')) return;
+
+      const form = e.target;
+      const submitBtn = form.querySelector('button[type="submit"]');
+      const originalText = submitBtn?.textContent;
+      if (submitBtn) {
+        submitBtn.disabled = true;
+        submitBtn.textContent = 'Clearing...';
+      }
+
+      try {
+        const response = await fetch(form.action, {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' }
+        });
+
+        const data = await response.json();
+        if (response.ok) {
+          alert(`Cleared ${data.itemsCleared} items, re-fetched ${data.itemsAdded} items from ${data.feedsProcessed} feeds.`);
+          location.reload();
+        } else {
+          alert(data.error || 'Failed to clear & re-sync');
+          if (submitBtn) {
+            submitBtn.disabled = false;
+            submitBtn.textContent = originalText;
+          }
+        }
+      } catch (err) {
+        alert('Failed to clear & re-sync: ' + err.message);
+        if (submitBtn) {
+          submitBtn.disabled = false;
+          submitBtn.textContent = originalText;
+        }
+      }
+    });
+
     // Handle delete feed
     document.querySelectorAll('[data-delete-feed]').forEach(btn => {
       btn.addEventListener('click', async (e) => {