ep_rss 11.0.27 → 11.0.28

package/index.js

@@ -1,5 +1,6 @@
 'use strict';
 
+const {Feed} = require('feed');
 const API = require('ep_etherpad-lite/node/db/API');
 const padManager = require('ep_etherpad-lite/node/db/PadManager');
 const settings = require('ep_etherpad-lite/node/utils/Settings');
@@ -9,9 +10,13 @@ if (!settings.rss) {
   console.log('ep_rss settings have not been configured');
 }
 
-const staleTime = settings.rss.staleTime || 300000; // 5 minutes, value should be set in settings
-const feeds = {}; // A nasty global
+// How long to serve a cached feed before regenerating. Bumped on every
+// pad edit anyway via the lastEdited check below, so this only affects
+// pads that haven't been edited recently.
+const staleTime = settings.rss.staleTime || 300000;
 
+// Per-pad cache: { lastEdited: number, body: string }.
+const feeds = {};
 
 exports.eejsBlock_htmlHead = (hookName, args, cb) => {
   args.content +=
@@ -28,79 +33,45 @@ exports.registerRoute = (hookName, args, cb) => {
   args.app.get('/p/:padId/atom.xml', redirectToFeed);
 
   args.app.get('/p/:padId/feed', async (req, res) => {
-    const fullURL = `${req.protocol}://${req.get('host')}${req.url}`;
     const padId = req.params.padId;
-    const padURL = `${req.protocol}://${req.get('host')}/p/${padId}`;
-    const dateString = new Date();
-    let isPublished = false; // is this item already published?
-    let text;
+    const origin = `${req.protocol}://${req.get('host')}`;
+    const padURL = `${origin}/p/${padId}`;
+    // Strip query string so the atom:self link matches the URL feed
+    // readers actually fetched (e.g. when they tack on cache-busters).
+    const feedURL = `${origin}${req.url.split('?')[0]}`;
 
-    /* When was this pad last edited and should we publish an RSS update? */
-    const message = await API.getLastEdited(padId);
-    const currTS = new Date().getTime();
-    if (!feeds[padId]) {
-      feeds[padId] = {};
+    const {lastEdited} = await API.getLastEdited(padId);
+    const now = Date.now();
+    const cached = feeds[padId];
+    if (cached && cached.lastEdited === lastEdited && now - cached.builtAt < staleTime) {
+      res.type('application/rss+xml');
+      res.send(cached.body);
+      return;
     }
 
-    // was the pad edited within the last 5 minutes?
-    if (currTS - message.lastEdited < staleTime) {
-      isPublished = isAlreadyPublished(padId, message.lastEdited);
+    const pad = await padManager.getPad(padId);
+    const feed = new Feed({
+      title: padId,
+      description: `Etherpad feed for ${padId}`,
+      id: padURL,
+      link: padURL,
+      language: 'en-us',
+      feedLinks: {rss: feedURL},
+      updated: new Date(lastEdited),
+    });
+    feed.addItem({
+      title: padId,
+      id: `${padURL}#${lastEdited}`,
+      link: padURL,
+      description: pad.text(),
+      date: new Date(lastEdited),
+    });
 
-      if (!isPublished) { // If it's not already published and it's gone stale
-        feeds[padId].lastEdited = message.lastEdited; // Add it to the timer object
-      }
-    } else {
-      if (!feeds[padId].feed) { // If it's not already stored in memory
-        console.debug('RSS Feed not already in memory so writing memory', feeds);
-        isPublished = false;
-        feeds[padId].lastEdited = message.lastEdited; // Add it to the timer object
-      } else {
-        isPublished = true;
-      }
-    }
-    if (!isPublished) {
-      const pad = await padManager.getPad(padId);
-      text = safe_tags(pad.text()).replace(/\n/g, '<br/>');
-    }
-
-    if (isPublished) {
-      console.debug(`Sending RSS from memory for ${padId}`);
-      res.contentType('rss');
-      res.send(feeds[padId].feed);
-    } else {
-      console.debug(`Building RSS for ${padId}`);
-      res.contentType('rss');
-      args.content = '<rss version="2.0" \n';
-      args.content += '   xmlns:content="http://purl.org/rss/1.0/modules/content/"\n';
-      args.content += '   xmlns:atom="http://www.w3.org/2005/Atom"\n';
-      args.content += '>\n';
-      args.content += '<channel>\n';
-      args.content += `<title>${padId}</title>\n`;
-      args.content += `<atom:link href="${fullURL}" rel="self" type="application/rss+xml" />`;
-      args.content += `<link>${padURL}</link>\n`;
-      args.content += '<description/>\n';
-      args.content += '<language>en-us</language>\n';
-      args.content += `<pubDate>${dateString}</pubDate>\n`;
-      args.content += `<lastBuildDate>${dateString}</lastBuildDate>\n`;
-      args.content += '<item>\n';
-      args.content += '<title>\n';
-      args.content += `${padId}\n`;
-      args.content += '</title>\n';
-      args.content += '<description>\n';
-      args.content += `<![CDATA[${text}]]>\n`;
-      args.content += '</description>\n';
-      args.content += `<link>${padURL}</link>\n`;
-      args.content += '</item>\n';
-      args.content += '</channel>\n';
-      args.content += '</rss>';
-      feeds[padId].feed = args.content;
-      res.send(args.content); // Send it to the requester
-    }
+    const body = feed.rss2();
+    feeds[padId] = {lastEdited, builtAt: now, body};
+    res.type('application/rss+xml');
+    res.send(body);
   });
+
   cb();
 };
-
-const safe_tags =
-    (str) => str.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
-
-const isAlreadyPublished = (padId, editTime) => (feeds[padId] === editTime);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "ep_rss",
   "description": "Get an RSS feed of pad updates",
-  "version": "11.0.27",
+  "version": "11.0.28",
   "author": {
     "name": "John McLear",
     "email": "john@mclear.co.uk",
@@ -19,6 +19,9 @@
     "type": "individual",
     "url": "https://etherpad.org/"
   },
+  "dependencies": {
+    "feed": "^5.2.1"
+  },
   "devDependencies": {
     "eslint": "^8.57.1",
     "eslint-config-etherpad": "^4.0.5",

package/static/tests/frontend-new/specs/feed.spec.ts

@@ -25,21 +25,79 @@ test.describe('ep_rss feed', () => {
     expect(res.status()).toBe(200);
     expect(res.headers()['content-type']).toContain('application/rss+xml');
     const body = await res.text();
-    expect(body).toMatch(/^<rss /);
+    expect(body).toMatch(/^<\?xml version="1\.0" encoding="utf-8"\?>\n<rss /);
+    // Channel title is a plain element; item title is CDATA-wrapped by
+    // the feed library. Both must carry the pad id.
     expect(body).toContain(`<title>${padId}</title>`);
+    expect(body).toContain(`<title><![CDATA[${padId}]]></title>`);
     expect(body).toContain(marker);
     expect(body.trim().endsWith('</rss>')).toBe(true);
   });
 
-  test('escapes HTML special characters in the description', async ({page, request}) => {
+  test('uses RFC-822 dates for pubDate and lastBuildDate (feedvalidator.org)', async ({page, request}) => {
+    await goToNewPad(page);
+    const padId = padIdFromUrl(page.url());
+    await writeToPad(page, 'date check');
+    await page.waitForTimeout(1200);
+    const body = await (await request.get(`${BASE_URL}/p/${padId}/feed`)).text();
+    // "Mon, 18 May 2026 09:53:13 GMT" — what Date.toUTCString() emits and
+    // what feedvalidator.org requires per RSS 2.0's RFC-822 rule.
+    const RFC822 = /^[A-Z][a-z]{2}, \d{2} [A-Z][a-z]{2} \d{4} \d{2}:\d{2}:\d{2} GMT$/;
+    const pub = body.match(/<pubDate>([^<]+)<\/pubDate>/g) || [];
+    const build = body.match(/<lastBuildDate>([^<]+)<\/lastBuildDate>/);
+    expect(pub.length).toBeGreaterThanOrEqual(1);
+    for (const tag of pub) {
+      const value = tag.replace(/<\/?pubDate>/g, '');
+      expect(value, `pubDate "${value}"`).toMatch(RFC822);
+    }
+    expect(build).not.toBeNull();
+    expect(build![1]).toMatch(RFC822);
+  });
+
+  test('item carries a stable non-permalink guid', async ({page, request}) => {
+    await goToNewPad(page);
+    const padId = padIdFromUrl(page.url());
+    await writeToPad(page, 'guid check');
+    await page.waitForTimeout(1200);
+
+    const first = await (await request.get(`${BASE_URL}/p/${padId}/feed`)).text();
+    const m = first.match(/<guid isPermaLink="false">([^<]+)<\/guid>/);
+    expect(m, 'guid element missing').not.toBeNull();
+    expect(m![1]).toContain(`/p/${padId}#`);
+
+    // Polling the same pad without editing must return the same guid so
+    // feed readers don't show a duplicate item every fetch.
+    const second = await (await request.get(`${BASE_URL}/p/${padId}/feed`)).text();
+    const m2 = second.match(/<guid isPermaLink="false">([^<]+)<\/guid>/);
+    expect(m2![1]).toBe(m![1]);
+  });
+
+  test('atom:self link drops the query string so it matches the document URL', async ({page, request}) => {
+    await goToNewPad(page);
+    const padId = padIdFromUrl(page.url());
+    await writeToPad(page, 'self-ref check');
+    await page.waitForTimeout(1200);
+    const body = await (await request.get(`${BASE_URL}/p/${padId}/feed?_=cachebust`)).text();
+    const self = body.match(/<atom:link href="([^"]+)" rel="self"/);
+    expect(self).not.toBeNull();
+    expect(self![1]).toBe(`${BASE_URL}/p/${padId}/feed`);
+  });
+
+  test('pad text with XML-significant characters is CDATA-wrapped', async ({page, request}) => {
     await goToNewPad(page);
     const padId = padIdFromUrl(page.url());
     await writeToPad(page, 'tags <b>&</b>');
     await page.waitForTimeout(1200);
 
     const body = await (await request.get(`${BASE_URL}/p/${padId}/feed`)).text();
-    expect(body).toContain('&lt;b&gt;&amp;&lt;/b&gt;');
-    expect(body).not.toContain('<b>&</b>');
+    // CDATA section protects raw `<` and `&` from XML parsing, so the
+    // feed library passes pad text through verbatim instead of double-
+    // encoding. The body must (a) be well-formed XML — that's covered
+    // implicitly by every test that parses the response — and (b)
+    // include the text inside the CDATA section.
+    const descMatch = body.match(/<description><!\[CDATA\[([\s\S]*?)\]\]><\/description>/);
+    expect(descMatch, 'item description must be CDATA-wrapped').not.toBeNull();
+    expect(descMatch![1]).toContain('tags <b>&</b>');
   });
 
   for (const alias of ['rss', 'feed.rss', 'atom.xml']) {