@rmdes/indiekit-endpoint-microsub 1.0.55 → 1.0.57

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,
+};

package/lib/controllers/reader/search.js

@@ -0,0 +1,157 @@
+/**
+ * Feed discovery UI
+ * @module controllers/reader/search
+ */
+
+import { discoverAndValidateFeeds } from "../../feeds/discovery.js";
+import { validateFeedUrl } from "../../feeds/validator.js";
+import { refreshFeedNow } from "../../polling/scheduler.js";
+import { getChannels, getChannel } from "../../storage/channels.js";
+import { createFeed } from "../../storage/feeds.js";
+import { getUserId } from "../../utils/auth.js";
+
+/**
+ * Search/discover feeds page
+ * @param {object} request - Express request
+ * @param {object} response - Express response
+ * @returns {Promise<void>}
+ */
+export async function searchPage(request, response) {
+  const { application } = request.app.locals;
+  const userId = getUserId(request);
+
+  const channelList = await getChannels(application, userId);
+
+  response.render("search", {
+    title: request.__("microsub.search.title"),
+    channels: channelList,
+    baseUrl: request.baseUrl,
+    readerBaseUrl: request.baseUrl,
+    activeView: "channels",
+    breadcrumbs: [
+      { text: "Reader", href: request.baseUrl },
+      { text: "Search" },
+    ],
+  });
+}
+
+/**
+ * Search for feeds from URL - enhanced with validation
+ * @param {object} request - Express request
+ * @param {object} response - Express response
+ * @returns {Promise<void>}
+ */
+export async function searchFeeds(request, response) {
+  const { application } = request.app.locals;
+  const userId = getUserId(request);
+  const { query } = request.body;
+
+  const channelList = await getChannels(application, userId);
+
+  let results = [];
+  let discoveryError = null;
+
+  if (query) {
+    try {
+      // Use enhanced discovery with validation
+      results = await discoverAndValidateFeeds(query);
+    } catch (error) {
+      discoveryError = error.message;
+    }
+  }
+
+  response.render("search", {
+    title: request.__("microsub.search.title"),
+    channels: channelList,
+    query,
+    results,
+    discoveryError,
+    searched: true,
+    baseUrl: request.baseUrl,
+    readerBaseUrl: request.baseUrl,
+    activeView: "channels",
+    breadcrumbs: [
+      { text: "Reader", href: request.baseUrl },
+      { text: "Search" },
+    ],
+  });
+}
+
+/**
+ * Subscribe to a feed from search results - with validation
+ * @param {object} request - Express request
+ * @param {object} response - Express response
+ * @returns {Promise<void>}
+ */
+export async function subscribe(request, response) {
+  const { application } = request.app.locals;
+  const userId = getUserId(request);
+  const { url, channel: channelUid, skipValidation } = request.body;
+
+  const channelDocument = await getChannel(application, channelUid, userId);
+  if (!channelDocument) {
+    return response.status(404).render("404");
+  }
+
+  // Validate feed unless explicitly skipped (for power users)
+  if (!skipValidation) {
+    const validation = await validateFeedUrl(url);
+
+    if (!validation.valid) {
+      const channelList = await getChannels(application, userId);
+      return response.render("search", {
+        title: request.__("microsub.search.title"),
+        channels: channelList,
+        query: url,
+        validationError: validation.error,
+        baseUrl: request.baseUrl,
+        readerBaseUrl: request.baseUrl,
+        activeView: "channels",
+        breadcrumbs: [
+          { text: "Reader", href: request.baseUrl },
+          { text: "Search" },
+        ],
+      });
+    }
+
+    // Warn about comments feeds but allow subscription
+    if (validation.isCommentsFeed) {
+      console.warn(`[Microsub] Subscribing to comments feed: ${url}`);
+    }
+  }
+
+  // Create feed subscription (throws DUPLICATE_FEED if already exists elsewhere)
+  try {
+    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/${channelUid}/feeds`);
+  } catch (error) {
+    if (error.code === "DUPLICATE_FEED") {
+      const channelList = await getChannels(application, userId);
+      return response.render("search", {
+        title: request.__("microsub.search.title"),
+        channels: channelList,
+        query: url,
+        validationError: `This feed already exists in channel "${error.channelName}"`,
+        baseUrl: request.baseUrl,
+        readerBaseUrl: request.baseUrl,
+        activeView: "channels",
+        breadcrumbs: [
+          { text: "Reader", href: request.baseUrl },
+          { text: "Search" },
+        ],
+      });
+    }
+    throw error;
+  }
+}