@rmdes/indiekit-endpoint-microsub 1.0.63 → 1.0.64

package/lib/controllers/reader/channel.js

@@ -10,7 +10,6 @@ import {
   updateChannelSettings,
   deleteChannel,
 } from "../../storage/channels.js";
-import { getFeedsForChannel } from "../../storage/feeds.js";
 import { getTimelineItems } from "../../storage/items.js";
 import { countReadItems } from "../../storage/items-read-state.js";
 import { getUserId } from "../../utils/auth.js";

package/lib/polling/scheduler.js

@@ -35,7 +35,7 @@ export function startScheduler(indiekit) {
   // Run immediately on start
   runSchedulerCycle();
 
-  console.log("[Microsub] Feed polling scheduler started");
+  console.info("[Microsub] Feed polling scheduler started");
 }
 
 /**
@@ -47,7 +47,7 @@ export function stopScheduler() {
     schedulerInterval = undefined;
   }
   indiekitInstance = undefined;
-  console.log("[Microsub] Feed polling scheduler stopped");
+  console.info("[Microsub] Feed polling scheduler stopped");
 }
 
 /**
@@ -74,13 +74,13 @@ async function runSchedulerCycle() {
       return;
     }
 
-    console.log(`[Microsub] Processing ${feeds.length} feeds due for refresh`);
+    console.info(`[Microsub] Processing ${feeds.length} feeds due for refresh`);
 
     const result = await processFeedBatch(application, feeds, {
       concurrency: BATCH_CONCURRENCY,
     });
 
-    console.log(
+    console.info(
       `[Microsub] Processed ${result.total} feeds: ${result.successful} successful, ` +
         `${result.failed} failed, ${result.itemsAdded} new items`,
     );

package/lib/storage/items-read-state.js

@@ -5,22 +5,17 @@
 
 import { ObjectId } from "mongodb";
 
-import { UNREAD_RETENTION_DAYS } from "../utils/constants.js";
+import {
+  MAX_FULL_READ_ITEMS,
+  UNREAD_RETENTION_DAYS,
+} from "../utils/constants.js";
 import { getCollection } from "./items.js";
 
-// Maximum number of full read items to keep per channel before stripping content.
-// Items beyond this limit are converted to lightweight dedup skeletons (channelId,
-// uid, readBy) so the poller doesn't re-ingest them as new unread entries.
-const MAX_FULL_READ_ITEMS = 200;
-
 /**
  * Cleanup old read items by stripping content but preserving dedup skeletons.
- * This prevents the vicious cycle where deleted read items get re-ingested as
+ * Prevents the vicious cycle where deleted read items get re-ingested as
  * unread by the poller because the dedup record (channelId + uid) was destroyed.
  *
- * AP items (feedId: null) are hard-deleted instead of stripped, since no poller
- * re-ingests them — they arrive via inbox push and don't need dedup skeletons.
- *
  * @param {object} collection - MongoDB collection
  * @param {ObjectId} channelObjectId - Channel ObjectId
  * @param {string} userId - User ID
@@ -32,7 +27,6 @@ async function cleanupOldReadItems(collection, channelObjectId, userId) {
   });
 
   if (readCount > MAX_FULL_READ_ITEMS) {
-    // Find old read items beyond the retention limit
     const itemsToCleanup = await collection
       .find({
         channelId: channelObjectId,
@@ -41,59 +35,36 @@ async function cleanupOldReadItems(collection, channelObjectId, userId) {
       })
       .sort({ published: -1, _id: -1 })
       .skip(MAX_FULL_READ_ITEMS)
-      .project({ _id: 1, feedId: 1 })
+      .project({ _id: 1 })
       .toArray();
 
     if (itemsToCleanup.length === 0) return;
 
-    // Separate AP items (feedId: null) from RSS items (feedId: ObjectId)
-    const apItemIds = [];
-    const rssItemIds = [];
-    for (const item of itemsToCleanup) {
-      if (item.feedId) {
-        rssItemIds.push(item._id);
-      } else {
-        apItemIds.push(item._id);
-      }
-    }
-
-    // Hard-delete AP items — no poller to re-ingest, skeletons are useless
-    if (apItemIds.length > 0) {
-      const deleted = await collection.deleteMany({
-        _id: { $in: apItemIds },
-      });
-      console.info(
-        `[Microsub] Deleted ${deleted.deletedCount} old AP read items`,
-      );
-    }
-
-    // Strip RSS items to dedup skeletons — poller would re-ingest if deleted
-    if (rssItemIds.length > 0) {
-      const stripped = await collection.updateMany(
-        { _id: { $in: rssItemIds } },
-        {
-          $set: { _stripped: true },
-          $unset: {
-            name: "",
-            content: "",
-            summary: "",
-            author: "",
-            category: "",
-            photo: "",
-            video: "",
-            audio: "",
-            likeOf: "",
-            repostOf: "",
-            bookmarkOf: "",
-            inReplyTo: "",
-            source: "",
-          },
+    const ids = itemsToCleanup.map((item) => item._id);
+    const stripped = await collection.updateMany(
+      { _id: { $in: ids } },
+      {
+        $set: { _stripped: true },
+        $unset: {
+          name: "",
+          content: "",
+          summary: "",
+          author: "",
+          category: "",
+          photo: "",
+          video: "",
+          audio: "",
+          likeOf: "",
+          repostOf: "",
+          bookmarkOf: "",
+          inReplyTo: "",
+          source: "",
         },
-      );
-      console.info(
-        `[Microsub] Stripped ${stripped.modifiedCount} old RSS read items (keeping ${MAX_FULL_READ_ITEMS} full)`,
-      );
-    }
+      },
+    );
+    console.info(
+      `[Microsub] Stripped ${stripped.modifiedCount} old read items (keeping ${MAX_FULL_READ_ITEMS} full)`,
+    );
   }
 }
 

package/lib/storage/items-retention.js

@@ -3,11 +3,9 @@
  * @module storage/items-retention
  */
 
+import { MAX_FULL_READ_ITEMS } from "../utils/constants.js";
 import { getCollection } from "./items.js";
 
-// Maximum number of full read items to keep per channel before stripping content.
-const MAX_FULL_READ_ITEMS = 200;
-
 // Global retention defaults. Each can be overridden per channel via
 // channel.settings.{maxItems,maxItemsPerFeed,maxUnreadAgeDays}. The "notifications"
 // channel is exempt from these caps entirely — webmentions are high-signal and

package/lib/utils/blogroll-notify.js

@@ -36,7 +36,7 @@ export async function notifyBlogroll(application, action, data) {
       status: "deleted",
     });
     if (deleted) {
-      console.log(
+      console.info(
         `[Microsub→Blogroll] Skipping follow for ${data.url} — previously deleted by user`,
       );
       return;
@@ -76,7 +76,7 @@ export async function notifyBlogroll(application, action, data) {
       { upsert: true },
     );
 
-    console.log(`[Microsub→Blogroll] Added/updated feed ${data.url}`);
+    console.info(`[Microsub→Blogroll] Added/updated feed ${data.url}`);
   } else if (action === "unfollow") {
     // Soft-delete the blog entry if it came from microsub
     const result = await collection.updateOne(
@@ -96,7 +96,7 @@ export async function notifyBlogroll(application, action, data) {
     );
 
     if (result.modifiedCount > 0) {
-      console.log(`[Microsub→Blogroll] Soft-deleted feed ${data.url}`);
+      console.info(`[Microsub→Blogroll] Soft-deleted feed ${data.url}`);
     }
   }
 }

package/lib/utils/constants.js

@@ -5,3 +5,10 @@
 
 /** Retention period for unread count queries (only count recent items) */
 export const UNREAD_RETENTION_DAYS = 30;
+
+/**
+ * Maximum number of full read items to keep per channel/user before stripping
+ * content. Items beyond this limit are converted to lightweight dedup skeletons
+ * (channelId, uid, readBy) so the poller doesn't re-ingest them as new unread.
+ */
+export const MAX_FULL_READ_ITEMS = 200;

package/lib/utils/jf2.js

@@ -29,115 +29,6 @@ export function generateChannelUid() {
   return result;
 }
 
-/**
- * Create a jf2 Item from normalized feed data
- * @param {object} data - Normalized item data
- * @param {object} source - Feed source metadata
- * @returns {object} jf2 Item object
- */
-export function createJf2Item(data, source) {
-  return {
-    type: "entry",
-    uid: data.uid,
-    url: data.url,
-    name: data.name || undefined,
-    content: data.content || undefined,
-    summary: data.summary || undefined,
-    published: data.published,
-    updated: data.updated || undefined,
-    author: data.author || undefined,
-    category: data.category || [],
-    photo: data.photo || [],
-    video: data.video || [],
-    audio: data.audio || [],
-    // Interaction types
-    "like-of": data.likeOf || [],
-    "repost-of": data.repostOf || [],
-    "bookmark-of": data.bookmarkOf || [],
-    "in-reply-to": data.inReplyTo || [],
-    // Internal properties (prefixed with _)
-    _id: data._id,
-    _is_read: data._is_read || false,
-    _source: source,
-  };
-}
-
-/**
- * Create a jf2 Card (author/person)
- * @param {object} data - Author data
- * @returns {object} jf2 Card object
- */
-export function createJf2Card(data) {
-  if (!data) return;
-
-  return {
-    type: "card",
-    name: data.name || undefined,
-    url: data.url || undefined,
-    photo: data.photo || undefined,
-  };
-}
-
-/**
- * Create a jf2 Content object
- * @param {string} text - Plain text content
- * @param {string} html - HTML content
- * @returns {object|undefined} jf2 Content object
- */
-export function createJf2Content(text, html) {
-  if (!text && !html) return;
-
-  return {
-    text: text || stripHtml(html),
-    html: html || undefined,
-  };
-}
-
-/**
- * Strip HTML tags from string
- * @param {string} html - HTML string
- * @returns {string} Plain text
- */
-export function stripHtml(html) {
-  if (!html) return "";
-  return html.replaceAll(/<[^>]*>/g, "").trim();
-}
-
-/**
- * Create a jf2 Feed response
- * @param {object} options - Feed options
- * @param {Array} options.items - Array of jf2 items
- * @param {object} options.paging - Pagination cursors
- * @returns {object} jf2 Feed object
- */
-export function createJf2Feed({ items, paging }) {
-  const feed = {
-    items: items || [],
-  };
-
-  if (paging) {
-    feed.paging = {};
-    if (paging.before) feed.paging.before = paging.before;
-    if (paging.after) feed.paging.after = paging.after;
-  }
-
-  return feed;
-}
-
-/**
- * Create a Channel response object
- * @param {object} channel - Channel data
- * @param {number} unreadCount - Number of unread items
- * @returns {object} Channel object for API response
- */
-export function createChannelResponse(channel, unreadCount = 0) {
-  return {
-    uid: channel.uid,
-    name: channel.name,
-    unread: unreadCount > 0 ? unreadCount : false,
-  };
-}
-
 /**
  * Create a Feed response object
  * @param {object} feed - Feed data

package/lib/utils/sanitize.js

@@ -1,6 +1,5 @@
 /**
- * Shared HTML sanitization configuration
- * Used by both RSS/Atom normalizer and ActivityPub outbox fetcher
+ * Shared HTML sanitization configuration used by the feed normalizers.
  * @module utils/sanitize
  */
 

package/lib/webmention/processor.js

@@ -30,7 +30,7 @@ export async function processWebmention(application, source, target, userId) {
   const verification = await verifyWebmention(source, target);
 
   if (!verification.verified) {
-    console.log(
+    console.info(
       `[Microsub] Webmention verification failed: ${verification.error}`,
     );
     return {
@@ -87,7 +87,7 @@ export async function processWebmention(application, source, target, userId) {
     });
   }
 
-  console.log(
+  console.info(
     `[Microsub] Webmention processed: ${verification.type} from ${source}`,
   );
 

package/lib/websub/handler.js

@@ -64,7 +64,7 @@ export async function verify(request, response) {
     });
   }
 
-  console.log(`[Microsub] WebSub subscription verified for ${feed.url}`);
+  console.info(`[Microsub] WebSub subscription verified for ${feed.url}`);
 
   // Return challenge to verify subscription
   response.type("text/plain").send(challenge);
@@ -143,7 +143,7 @@ async function processWebsubContent(application, feed, contentType, body) {
     // Parse the pushed content
     const parsed = await parseFeed(content, feed.url, { contentType });
 
-    console.log(
+    console.info(
       `[Microsub] Processing ${parsed.items.length} items from WebSub push for ${feed.url}`,
     );
 

package/locales/en.json

@@ -10,7 +10,6 @@
       "showRead": "Show read ({{count}})",
       "hideRead": "Hide read items",
       "allRead": "All caught up!",
-      "newer": "Newer",
       "older": "Older"
     },
     "channels": {
@@ -18,34 +17,21 @@
       "name": "Channel name",
       "new": "New channel",
       "create": "Create channel",
-      "delete": "Delete channel",
       "settings": "Channel settings",
-      "empty": "No channels yet. Create one to get started.",
-      "notifications": "Notifications"
+      "empty": "No channels yet. Create one to get started."
     },
     "timeline": {
-      "title": "Timeline",
       "empty": "No items in this channel",
-      "markRead": "Mark as read",
-      "markUnread": "Mark as unread",
-      "remove": "Remove"
+      "markRead": "Mark as read"
     },
     "feeds": {
       "title": "Feeds",
       "follow": "Follow",
       "subscribe": "Subscribe to a feed",
-      "unfollow": "Unfollow",
       "empty": "No feeds followed in this channel",
       "url": "Feed URL",
       "urlPlaceholder": "https://example.com/feed.xml",
-      "edit": "Edit feed",
-      "rediscover": "Rediscover feed",
-      "refresh": "Refresh now",
-      "status": {
-        "active": "Active",
-        "error": "Error",
-        "stale": "Stale"
-      }
+      "edit": "Edit feed"
     },
     "item": {
       "reply": "Reply",
@@ -101,20 +87,10 @@
       "submit": "Search",
       "noResults": "No results found"
     },
-    "preview": {
-      "title": "Preview",
-      "subscribe": "Subscribe to this feed"
-    },
     "views": {
       "channels": "Channels",
       "deck": "Deck",
       "timeline": "Timeline"
-    },
-    "error": {
-      "channelNotFound": "Channel not found",
-      "feedNotFound": "Feed not found",
-      "invalidUrl": "Invalid URL",
-      "invalidAction": "Invalid action"
     }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rmdes/indiekit-endpoint-microsub",
-  "version": "1.0.63",
+  "version": "1.0.64",
   "description": "Microsub endpoint for Indiekit. Enables subscribing to feeds and reading content using the Microsub protocol.",
   "keywords": [
     "indiekit",

package/lib/search/indexer.js

@@ -1,90 +0,0 @@
-/**
- * Search indexer for MongoDB text search
- * @module search/indexer
- */
-
-/**
- * Create text indexes for microsub items
- * @param {object} application - Indiekit application
- * @returns {Promise<void>}
- */
-export async function createSearchIndexes(application) {
-  const itemsCollection = application.collections.get("microsub_items");
-
-  // Create compound text index for full-text search
-  await itemsCollection.createIndex(
-    {
-      name: "text",
-      "content.text": "text",
-      "content.html": "text",
-      summary: "text",
-      "author.name": "text",
-    },
-    {
-      name: "text_search",
-      weights: {
-        name: 10,
-        "content.text": 5,
-        summary: 3,
-        "author.name": 2,
-      },
-      default_language: "english",
-      background: true,
-    },
-  );
-
-  // Create index for channel + published for efficient timeline queries
-  await itemsCollection.createIndex(
-    { channelId: 1, published: -1 },
-    { name: "channel_timeline" },
-  );
-
-  // Create index for deduplication
-  await itemsCollection.createIndex(
-    { channelId: 1, uid: 1 },
-    { name: "channel_uid", unique: true },
-  );
-
-  // Create index for feed-based queries
-  await itemsCollection.createIndex({ feedId: 1 }, { name: "feed_items" });
-}
-
-/**
- * Rebuild search indexes (drops and recreates)
- * @param {object} application - Indiekit application
- * @returns {Promise<void>}
- */
-export async function rebuildSearchIndexes(application) {
-  const itemsCollection = application.collections.get("microsub_items");
-
-  // Drop existing text index
-  try {
-    await itemsCollection.dropIndex("text_search");
-  } catch {
-    // Index may not exist
-  }
-
-  // Recreate indexes
-  await createSearchIndexes(application);
-}
-
-/**
- * Get search index stats
- * @param {object} application - Indiekit application
- * @returns {Promise<object>} Index statistics
- */
-export async function getSearchIndexStats(application) {
-  const itemsCollection = application.collections.get("microsub_items");
-
-  const indexes = await itemsCollection.indexes();
-  const stats = await itemsCollection.stats();
-
-  return {
-    indexes: indexes.map((index) => ({
-      name: index.name,
-      key: index.key,
-    })),
-    totalDocuments: stats.count,
-    size: stats.size,
-  };
-}

package/lib/storage/items-search.js

@@ -1,34 +0,0 @@
-/**
- * Timeline item search
- * @module storage/items-search
- */
-
-import { ObjectId } from "mongodb";
-
-import { getCollection, transformToJf2 } from "./items.js";
-
-/**
- * Search items by text
- * @param {object} application - Indiekit application
- * @param {ObjectId|string} channelId - Channel ObjectId
- * @param {string} query - Search query
- * @param {number} [limit] - Max results
- * @returns {Promise<Array>} Array of matching items
- */
-export async function searchItems(application, channelId, query, limit = 20) {
-  const collection = getCollection(application);
-  const objectId =
-    typeof channelId === "string" ? new ObjectId(channelId) : channelId;
-
-  // Use MongoDB text index for efficient full-text search
-  const items = await collection
-    .find({
-      channelId: objectId,
-      $text: { $search: query },
-    })
-    .sort({ score: { $meta: "textScore" } })
-    .limit(limit)
-    .toArray();
-
-  return items.map((item) => transformToJf2(item));
-}