@rmdes/indiekit-endpoint-microsub 1.0.56 → 1.0.57

package/lib/controllers/reader/deck.js

@@ -0,0 +1,129 @@
+/**
+ * Deck view
+ * @module controllers/reader/deck
+ */
+
+import { getChannelsWithColors } from "../../storage/channels.js";
+import { getTimelineItems } from "../../storage/items.js";
+import { getDeckConfig, saveDeckConfig } from "../../storage/deck.js";
+import { getUserId } from "../../utils/auth.js";
+import { proxyItemImages } from "../../media/proxy.js";
+
+/**
+ * Deck view - TweetDeck-style columns
+ * @param {object} request - Express request
+ * @param {object} response - Express response
+ */
+export async function deck(request, response) {
+  const { application } = request.app.locals;
+  const userId = getUserId(request);
+
+  const channelList = await getChannelsWithColors(application, userId);
+  const deckConfig = await getDeckConfig(application, userId);
+
+  // Determine which channels to show as columns
+  let columnChannels;
+  if (deckConfig?.columns?.length > 0) {
+    // Use saved config order
+    const channelMap = new Map(channelList.map((ch) => [ch._id.toString(), ch]));
+    columnChannels = deckConfig.columns
+      .map((col) => channelMap.get(col.channelId.toString()))
+      .filter(Boolean);
+  } else {
+    // Default: all channels except notifications
+    columnChannels = channelList.filter((ch) => ch.uid !== "notifications");
+  }
+
+  // Fetch items for each column (limited to 10 per column for performance)
+  // Batch in groups of 4 to avoid overwhelming MongoDB with parallel queries
+  const proxyBaseUrl = application.url;
+  const columns = [];
+  for (let i = 0; i < columnChannels.length; i += 4) {
+    const batch = columnChannels.slice(i, i + 4);
+    const batchResults = await Promise.all(
+      batch.map(async (channel) => {
+        const result = await getTimelineItems(application, channel._id, {
+          userId,
+          limit: 10,
+        });
+
+        if (proxyBaseUrl && result.items) {
+          result.items = result.items.map((item) =>
+            proxyItemImages(item, proxyBaseUrl),
+          );
+        }
+
+        return {
+          channel,
+          items: result.items,
+          paging: result.paging,
+        };
+      }),
+    );
+    columns.push(...batchResults);
+  }
+
+  // Set view preference cookie
+  if (request.session) request.session.microsubView = "deck";
+
+  response.render("deck", {
+    title: "Deck",
+    columns,
+    baseUrl: request.baseUrl,
+    readerBaseUrl: request.baseUrl,
+    activeView: "deck",
+    breadcrumbs: [
+      { text: "Reader", href: request.baseUrl },
+      { text: "Deck" },
+    ],
+  });
+}
+
+/**
+ * Deck settings page
+ * @param {object} request - Express request
+ * @param {object} response - Express response
+ */
+export async function deckSettings(request, response) {
+  const { application } = request.app.locals;
+  const userId = getUserId(request);
+
+  const channelList = await getChannelsWithColors(application, userId);
+  const deckConfig = await getDeckConfig(application, userId);
+
+  const selectedIds = deckConfig?.columns
+    ? deckConfig.columns.map((col) => col.channelId.toString())
+    : channelList.filter((ch) => ch.uid !== "notifications").map((ch) => ch._id.toString());
+
+  response.render("deck-settings", {
+    title: "Deck settings",
+    channels: channelList,
+    selectedIds,
+    baseUrl: request.baseUrl,
+    readerBaseUrl: request.baseUrl,
+    activeView: "deck",
+    breadcrumbs: [
+      { text: "Reader", href: request.baseUrl },
+      { text: "Deck", href: `${request.baseUrl}/deck` },
+      { text: "Settings" },
+    ],
+  });
+}
+
+/**
+ * Save deck settings
+ * @param {object} request - Express request
+ * @param {object} response - Express response
+ */
+export async function saveDeckSettings(request, response) {
+  const { application } = request.app.locals;
+  const userId = getUserId(request);
+
+  let { columns } = request.body;
+  if (!columns) columns = [];
+  if (!Array.isArray(columns)) columns = [columns];
+
+  await saveDeckConfig(application, userId, columns);
+
+  response.redirect(`${request.baseUrl}/deck`);
+}

package/lib/controllers/reader/feed-repair.js

@@ -0,0 +1,117 @@
+/**
+ * Feed repair operations (rediscover + force refresh)
+ * @module controllers/reader/feed-repair
+ */
+
+import { discoverAndValidateFeeds, getBestFeed } from "../../feeds/discovery.js";
+import { refreshFeedNow } from "../../polling/scheduler.js";
+import { getChannel } from "../../storage/channels.js";
+import { getFeedById, updateFeed, updateFeedStatus } from "../../storage/feeds.js";
+import { getUserId } from "../../utils/auth.js";
+
+/**
+ * Rediscover feed - run discovery on URL to find actual RSS feed
+ * @param {object} request - Express request
+ * @param {object} response - Express response
+ * @returns {Promise<void>}
+ */
+export async function rediscoverFeed(request, response) {
+  const { application } = request.app.locals;
+  const userId = getUserId(request);
+  const { uid, feedId } = request.params;
+
+  const channelDocument = await getChannel(application, uid, userId);
+  if (!channelDocument) {
+    return response.status(404).render("404");
+  }
+
+  const feed = await getFeedById(application, feedId);
+  if (!feed || feed.channelId.toString() !== channelDocument._id.toString()) {
+    return response.status(404).render("404");
+  }
+
+  // Run feed discovery on the current URL
+  try {
+    const discoveredFeeds = await discoverAndValidateFeeds(feed.url);
+    const bestFeed = getBestFeed(discoveredFeeds);
+
+    if (bestFeed && bestFeed.url !== feed.url) {
+      // Found a different (better) feed URL - update the record
+      await updateFeed(application, feedId, {
+        url: bestFeed.url,
+        title: bestFeed.title || feed.title,
+        status: "active",
+        lastError: undefined,
+        lastErrorAt: undefined,
+        consecutiveErrors: 0,
+      });
+
+      console.info(
+        `[Microsub] Rediscovered feed: ${feed.url} -> ${bestFeed.url}`,
+      );
+
+      // Trigger immediate fetch
+      refreshFeedNow(application, feedId).catch((error) => {
+        console.error(
+          `[Microsub] Error refreshing rediscovered feed:`,
+          error.message,
+        );
+      });
+    } else if (bestFeed) {
+      // Same URL but valid - just reset error state and refresh
+      await updateFeedStatus(application, feedId, { success: true });
+      await updateFeed(application, feedId, {
+        status: "active",
+        lastError: undefined,
+        lastErrorAt: undefined,
+        consecutiveErrors: 0,
+      });
+
+      refreshFeedNow(application, feedId).catch((error) => {
+        console.error(`[Microsub] Error refreshing feed:`, error.message);
+      });
+    } else {
+      // No valid feed found
+      await updateFeedStatus(application, feedId, {
+        success: false,
+        error: "No valid feed found at this URL",
+      });
+    }
+  } catch (error) {
+    await updateFeedStatus(application, feedId, {
+      success: false,
+      error: error.message,
+    });
+  }
+
+  response.redirect(`${request.baseUrl}/channels/${uid}/feeds`);
+}
+
+/**
+ * Force refresh a feed
+ * @param {object} request - Express request
+ * @param {object} response - Express response
+ * @returns {Promise<void>}
+ */
+export async function refreshFeed(request, response) {
+  const { application } = request.app.locals;
+  const userId = getUserId(request);
+  const { uid, feedId } = request.params;
+
+  const channelDocument = await getChannel(application, uid, userId);
+  if (!channelDocument) {
+    return response.status(404).render("404");
+  }
+
+  const feed = await getFeedById(application, feedId);
+  if (!feed || feed.channelId.toString() !== channelDocument._id.toString()) {
+    return response.status(404).render("404");
+  }
+
+  // Trigger immediate fetch
+  refreshFeedNow(application, feedId).catch((error) => {
+    console.error(`[Microsub] Error refreshing feed ${feed.url}:`, error.message);
+  });
+
+  response.redirect(`${request.baseUrl}/channels/${uid}/feeds`);
+}

package/lib/controllers/reader/feed.js

@@ -0,0 +1,246 @@
+/**
+ * Feed management
+ * @module controllers/reader/feed
+ */
+
+import { validateFeedUrl } from "../../feeds/validator.js";
+import { refreshFeedNow } from "../../polling/scheduler.js";
+import { getChannel } from "../../storage/channels.js";
+import {
+  getFeedsForChannel,
+  getFeedById,
+  createFeed,
+  deleteFeed,
+  updateFeed,
+} from "../../storage/feeds.js";
+import { getUserId } from "../../utils/auth.js";
+
+export { rediscoverFeed, refreshFeed } from "./feed-repair.js";
+
+/**
+ * View feeds for a channel
+ * @param {object} request - Express request
+ * @param {object} response - Express response
+ * @returns {Promise<void>}
+ */
+export async function feeds(request, response) {
+  const { application } = request.app.locals;
+  const userId = getUserId(request);
+  const { uid } = request.params;
+
+  const channelDocument = await getChannel(application, uid, userId);
+  if (!channelDocument) {
+    return response.status(404).render("404");
+  }
+
+  const feedList = await getFeedsForChannel(application, channelDocument._id);
+
+  response.render("feeds", {
+    title: request.__("microsub.feeds.title"),
+    channel: channelDocument,
+    feeds: feedList,
+    baseUrl: request.baseUrl,
+    readerBaseUrl: request.baseUrl,
+    activeView: "channels",
+    breadcrumbs: [
+      { text: "Reader", href: request.baseUrl },
+      { text: "Channels", href: `${request.baseUrl}/channels` },
+      { text: channelDocument.name, href: `${request.baseUrl}/channels/${uid}` },
+      { text: "Feeds" },
+    ],
+  });
+}
+
+/**
+ * Add feed to channel
+ * @param {object} request - Express request
+ * @param {object} response - Express response
+ * @returns {Promise<void>}
+ */
+export async function addFeed(request, response) {
+  const { application } = request.app.locals;
+  const userId = getUserId(request);
+  const { uid } = request.params;
+  const { url } = request.body;
+
+  const channelDocument = await getChannel(application, uid, userId);
+  if (!channelDocument) {
+    return response.status(404).render("404");
+  }
+
+  try {
+    // Create feed subscription (throws DUPLICATE_FEED if already exists)
+    const feed = await createFeed(application, {
+      channelId: channelDocument._id,
+      url,
+      title: undefined,
+      photo: undefined,
+    });
+
+    // Trigger immediate fetch in background
+    refreshFeedNow(application, feed._id).catch((error) => {
+      console.error(`[Microsub] Error fetching new feed ${url}:`, error.message);
+    });
+
+    response.redirect(`${request.baseUrl}/channels/${uid}/feeds`);
+  } catch (error) {
+    if (error.code === "DUPLICATE_FEED") {
+      // Re-render feeds page with error message
+      const feedList = await getFeedsForChannel(application, channelDocument._id);
+      return response.render("feeds", {
+        title: request.__("microsub.feeds.title"),
+        channel: channelDocument,
+        feeds: feedList,
+        baseUrl: request.baseUrl,
+        readerBaseUrl: request.baseUrl,
+        activeView: "channels",
+        error: `This feed already exists in channel "${error.channelName}"`,
+        breadcrumbs: [
+          { text: "Reader", href: request.baseUrl },
+          { text: "Channels", href: `${request.baseUrl}/channels` },
+          { text: channelDocument.name, href: `${request.baseUrl}/channels/${uid}` },
+          { text: "Feeds" },
+        ],
+      });
+    }
+    throw error;
+  }
+}
+
+/**
+ * Remove feed from channel
+ * @param {object} request - Express request
+ * @param {object} response - Express response
+ * @returns {Promise<void>}
+ */
+export async function removeFeed(request, response) {
+  const { application } = request.app.locals;
+  const userId = getUserId(request);
+  const { uid } = request.params;
+  const { url } = request.body;
+
+  const channelDocument = await getChannel(application, uid, userId);
+  if (!channelDocument) {
+    return response.status(404).render("404");
+  }
+
+  await deleteFeed(application, channelDocument._id, url);
+
+  response.redirect(`${request.baseUrl}/channels/${uid}/feeds`);
+}
+
+/**
+ * View single feed details with status - redirects to edit form
+ * @param {object} request - Express request
+ * @param {object} response - Express response
+ * @returns {Promise<void>}
+ */
+export async function feedDetails(request, response) {
+  const { uid, feedId } = request.params;
+  // Redirect to edit form which shows all details
+  response.redirect(`${request.baseUrl}/channels/${uid}/feeds/${feedId}/edit`);
+}
+
+/**
+ * Edit feed URL form
+ * @param {object} request - Express request
+ * @param {object} response - Express response
+ * @returns {Promise<void>}
+ */
+export async function editFeedForm(request, response) {
+  const { application } = request.app.locals;
+  const userId = getUserId(request);
+  const { uid, feedId } = request.params;
+
+  const channelDocument = await getChannel(application, uid, userId);
+  if (!channelDocument) {
+    return response.status(404).render("404");
+  }
+
+  const feed = await getFeedById(application, feedId);
+  if (!feed || feed.channelId.toString() !== channelDocument._id.toString()) {
+    return response.status(404).render("404");
+  }
+
+  response.render("feed-edit", {
+    title: request.__("microsub.feeds.edit"),
+    channel: channelDocument,
+    feed,
+    baseUrl: request.baseUrl,
+    readerBaseUrl: request.baseUrl,
+    activeView: "channels",
+    breadcrumbs: [
+      { text: "Reader", href: request.baseUrl },
+      { text: "Channels", href: `${request.baseUrl}/channels` },
+      { text: channelDocument.name, href: `${request.baseUrl}/channels/${uid}` },
+      { text: "Feeds", href: `${request.baseUrl}/channels/${uid}/feeds` },
+      { text: "Edit" },
+    ],
+  });
+}
+
+/**
+ * Update feed URL
+ * @param {object} request - Express request
+ * @param {object} response - Express response
+ * @returns {Promise<void>}
+ */
+export async function updateFeedUrl(request, response) {
+  const { application } = request.app.locals;
+  const userId = getUserId(request);
+  const { uid, feedId } = request.params;
+  const { url: newUrl } = request.body;
+
+  const channelDocument = await getChannel(application, uid, userId);
+  if (!channelDocument) {
+    return response.status(404).render("404");
+  }
+
+  const feed = await getFeedById(application, feedId);
+  if (!feed || feed.channelId.toString() !== channelDocument._id.toString()) {
+    return response.status(404).render("404");
+  }
+
+  // Validate the new URL is a valid feed
+  const validation = await validateFeedUrl(newUrl);
+
+  if (!validation.valid) {
+    return response.render("feed-edit", {
+      title: request.__("microsub.feeds.edit"),
+      channel: channelDocument,
+      feed,
+      error: validation.error,
+      baseUrl: request.baseUrl,
+      readerBaseUrl: request.baseUrl,
+      activeView: "channels",
+      breadcrumbs: [
+        { text: "Reader", href: request.baseUrl },
+        { text: "Channels", href: `${request.baseUrl}/channels` },
+        { text: channelDocument.name, href: `${request.baseUrl}/channels/${uid}` },
+        { text: "Feeds", href: `${request.baseUrl}/channels/${uid}/feeds` },
+        { text: "Edit" },
+      ],
+    });
+  }
+
+  // Update the feed URL and reset error state
+  await updateFeed(application, feedId, {
+    url: newUrl,
+    title: validation.title || feed.title,
+    status: "active",
+    lastError: undefined,
+    lastErrorAt: undefined,
+    consecutiveErrors: 0,
+  });
+
+  // Trigger immediate fetch
+  refreshFeedNow(application, feedId).catch((error) => {
+    console.error(
+      `[Microsub] Error refreshing updated feed ${newUrl}:`,
+      error.message,
+    );
+  });
+
+  response.redirect(`${request.baseUrl}/channels/${uid}/feeds`);
+}
+

package/lib/controllers/reader/index.js

@@ -0,0 +1,126 @@
+/**
+ * Reader controller - barrel re-export
+ * @module controllers/reader
+ */
+
+export {
+  index,
+  channels,
+  newChannel,
+  createChannelAction,
+  channel,
+  channelHtml,
+  settings,
+  updateSettings,
+  deleteChannelAction,
+} from "./channel.js";
+
+export {
+  feeds,
+  addFeed,
+  removeFeed,
+  feedDetails,
+  editFeedForm,
+  updateFeedUrl,
+  rediscoverFeed,
+  refreshFeed,
+} from "./feed.js";
+
+export {
+  timeline,
+  timelineHtml,
+  markAllRead,
+  markViewRead,
+  item,
+} from "./timeline.js";
+
+export { compose, submitCompose } from "./compose.js";
+
+export { searchPage, searchFeeds, subscribe } from "./search.js";
+
+export {
+  actorProfile,
+  followActorAction,
+  unfollowActorAction,
+} from "./actor.js";
+
+export { deck, deckSettings, saveDeckSettings } from "./deck.js";
+
+import {
+  index,
+  channels,
+  newChannel,
+  createChannelAction,
+  channel,
+  channelHtml,
+  settings,
+  updateSettings,
+  deleteChannelAction,
+} from "./channel.js";
+
+import {
+  feeds,
+  addFeed,
+  removeFeed,
+  feedDetails,
+  editFeedForm,
+  updateFeedUrl,
+  rediscoverFeed,
+  refreshFeed,
+} from "./feed.js";
+
+import {
+  timeline,
+  timelineHtml,
+  markAllRead,
+  markViewRead,
+  item,
+} from "./timeline.js";
+
+import { compose, submitCompose } from "./compose.js";
+
+import { searchPage, searchFeeds, subscribe } from "./search.js";
+
+import {
+  actorProfile,
+  followActorAction,
+  unfollowActorAction,
+} from "./actor.js";
+
+import { deck, deckSettings, saveDeckSettings } from "./deck.js";
+
+export const readerController = {
+  index,
+  channels,
+  newChannel,
+  createChannel: createChannelAction,
+  channel,
+  channelHtml,
+  settings,
+  updateSettings,
+  markAllRead,
+  markViewRead,
+  deleteChannel: deleteChannelAction,
+  feeds,
+  addFeed,
+  removeFeed,
+  feedDetails,
+  editFeedForm,
+  updateFeedUrl,
+  rediscoverFeed,
+  refreshFeed,
+  item,
+  compose,
+  submitCompose,
+  searchPage,
+  searchFeeds,
+  subscribe,
+  actorProfile,
+  followActorAction,
+  unfollowActorAction,
+  timeline,
+  timelineHtml,
+  deck,
+  deckSettings,
+  saveDeckSettings,
+};