@rmdes/indiekit-endpoint-microsub 1.0.64 → 1.0.66

package/lib/storage/filters.js

@@ -1,117 +1,22 @@
 /**
- * Filter storage operations (mute, block, channel filters)
+ * Item filtering: exclude-types and exclude-regex predicates applied during
+ * feed ingestion. Used by `lib/polling/processor.js` when deciding whether a
+ * newly-parsed item should be stored.
+ *
+ * Historical note: this module previously also held mute/block storage
+ * (microsub_muted / microsub_blocked operations). That code path was abandoned
+ * — those collections are managed directly by `lib/controllers/mute.js` and
+ * `lib/controllers/block.js` against MongoDB without an intermediate storage
+ * helper layer. Only the per-channel exclude filters remain here.
+ *
  * @module storage/filters
  */
 
-import { ObjectId } from "mongodb";
-
-/**
- * Get muted collection
- * @param {object} application - Indiekit application
- * @returns {object} MongoDB collection
- */
-function getMutedCollection(application) {
-  return application.collections.get("microsub_muted");
-}
-
-/**
- * Get blocked collection
- * @param {object} application - Indiekit application
- * @returns {object} MongoDB collection
- */
-function getBlockedCollection(application) {
-  return application.collections.get("microsub_blocked");
-}
-
-/**
- * Check if a URL is muted for a user/channel
- * @param {object} application - Indiekit application
- * @param {string} userId - User ID
- * @param {ObjectId|string} channelId - Channel ObjectId
- * @param {string} url - URL to check
- * @returns {Promise<boolean>} Whether the URL is muted
- */
-export async function isMuted(application, userId, channelId, url) {
-  const collection = getMutedCollection(application);
-  const channelObjectId =
-    typeof channelId === "string" ? new ObjectId(channelId) : channelId;
-
-  // Check for channel-specific mute
-  const channelMute = await collection.findOne({
-    userId,
-    channelId: channelObjectId,
-    url,
-  });
-  if (channelMute) return true;
-
-  // Check for global mute (no channelId)
-  const globalMute = await collection.findOne({
-    userId,
-    channelId: { $exists: false },
-    url,
-  });
-  return !!globalMute;
-}
-
-/**
- * Check if a URL is blocked for a user
- * @param {object} application - Indiekit application
- * @param {string} userId - User ID
- * @param {string} url - URL to check
- * @returns {Promise<boolean>} Whether the URL is blocked
- */
-export async function isBlocked(application, userId, url) {
-  const collection = getBlockedCollection(application);
-  const blocked = await collection.findOne({ userId, url });
-  return !!blocked;
-}
-
-/**
- * Check if an item passes all filters
- * @param {object} application - Indiekit application
- * @param {string} userId - User ID
- * @param {object} channel - Channel document with settings
- * @param {object} item - Feed item to check
- * @returns {Promise<boolean>} Whether the item passes all filters
- */
-export async function passesAllFilters(application, userId, channel, item) {
-  // Check if author URL is blocked
-  if (
-    item.author?.url &&
-    (await isBlocked(application, userId, item.author.url))
-  ) {
-    return false;
-  }
-
-  // Check if source URL is muted
-  if (
-    item._source?.url &&
-    (await isMuted(application, userId, channel._id, item._source.url))
-  ) {
-    return false;
-  }
-
-  // Check channel settings filters
-  if (channel?.settings) {
-    // Check excludeTypes
-    if (!passesTypeFilter(item, channel.settings)) {
-      return false;
-    }
-
-    // Check excludeRegex
-    if (!passesRegexFilter(item, channel.settings)) {
-      return false;
-    }
-  }
-
-  return true;
-}
-
 /**
- * Check if an item passes the excludeTypes filter
+ * Check if an item passes the channel.settings.excludeTypes filter.
  * @param {object} item - Feed item
  * @param {object} settings - Channel settings
- * @returns {boolean} Whether the item passes
+ * @returns {boolean} True when the item should be kept
  */
 export function passesTypeFilter(item, settings) {
   if (!settings.excludeTypes || settings.excludeTypes.length === 0) {
@@ -123,10 +28,10 @@ export function passesTypeFilter(item, settings) {
 }
 
 /**
- * Check if an item passes the excludeRegex filter
+ * Check if an item passes the channel.settings.excludeRegex filter.
  * @param {object} item - Feed item
  * @param {object} settings - Channel settings
- * @returns {boolean} Whether the item passes
+ * @returns {boolean} True when the item should be kept
  */
 export function passesRegexFilter(item, settings) {
   if (!settings.excludeRegex) {
@@ -146,17 +51,26 @@ export function passesRegexFilter(item, settings) {
 
     return !regex.test(searchText);
   } catch {
-    // Invalid regex, skip filter
+    // Invalid regex — skip the filter rather than rejecting every item.
     return true;
   }
 }
 
 /**
- * Detect the interaction type of an item
+ * Classify an item by its interaction property. Internal helper for
+ * passesTypeFilter — only its symbolic return value (one of "like" | "repost"
+ * | "bookmark" | "reply" | "rsvp" | "checkin" | "post") is compared against
+ * the excludeTypes list.
+ *
+ * Note: a similar but stricter classifier exists in `lib/utils/jf2.js` for
+ * API-response shaping. The two cannot trivially be merged because this one
+ * treats kebab-case keys only and emits a "post" default that the jf2 one
+ * doesn't.
+ *
  * @param {object} item - Feed item
  * @returns {string} Interaction type
  */
-export function detectInteractionType(item) {
+function detectInteractionType(item) {
   if (item["like-of"] && item["like-of"].length > 0) {
     return "like";
   }
@@ -178,88 +92,3 @@ export function detectInteractionType(item) {
 
   return "post";
 }
-
-/**
- * Get all muted URLs for a user/channel
- * @param {object} application - Indiekit application
- * @param {string} userId - User ID
- * @param {ObjectId|string} [channelId] - Channel ObjectId (optional, for channel-specific)
- * @returns {Promise<Array>} Array of muted URLs
- */
-export async function getMutedUrls(application, userId, channelId) {
-  const collection = getMutedCollection(application);
-  const filter = { userId };
-
-  if (channelId) {
-    const channelObjectId =
-      typeof channelId === "string" ? new ObjectId(channelId) : channelId;
-    filter.channelId = channelObjectId;
-  }
-
-  // eslint-disable-next-line unicorn/no-array-callback-reference -- filter is MongoDB query object
-  const muted = await collection.find(filter).toArray();
-  return muted.map((m) => m.url);
-}
-
-/**
- * Get all blocked URLs for a user
- * @param {object} application - Indiekit application
- * @param {string} userId - User ID
- * @returns {Promise<Array>} Array of blocked URLs
- */
-export async function getBlockedUrls(application, userId) {
-  const collection = getBlockedCollection(application);
-  const blocked = await collection.find({ userId }).toArray();
-  return blocked.map((b) => b.url);
-}
-
-/**
- * Update channel filter settings
- * @param {object} application - Indiekit application
- * @param {ObjectId|string} channelId - Channel ObjectId
- * @param {object} filters - Filter settings to update
- * @param {Array} [filters.excludeTypes] - Post types to exclude
- * @param {string} [filters.excludeRegex] - Regex pattern to exclude
- * @returns {Promise<object>} Updated channel
- */
-export async function updateChannelFilters(application, channelId, filters) {
-  const collection = application.collections.get("microsub_channels");
-  const channelObjectId =
-    typeof channelId === "string" ? new ObjectId(channelId) : channelId;
-
-  const updateFields = {};
-
-  if (filters.excludeTypes !== undefined) {
-    updateFields["settings.excludeTypes"] = filters.excludeTypes;
-  }
-
-  if (filters.excludeRegex !== undefined) {
-    updateFields["settings.excludeRegex"] = filters.excludeRegex;
-  }
-
-  const result = await collection.findOneAndUpdate(
-    { _id: channelObjectId },
-    { $set: updateFields },
-    { returnDocument: "after" },
-  );
-
-  return result;
-}
-
-/**
- * Create indexes for filter collections
- * @param {object} application - Indiekit application
- * @returns {Promise<void>}
- */
-export async function createFilterIndexes(application) {
-  const mutedCollection = getMutedCollection(application);
-  const blockedCollection = getBlockedCollection(application);
-
-  // Muted collection indexes
-  await mutedCollection.createIndex({ userId: 1, channelId: 1, url: 1 });
-  await mutedCollection.createIndex({ userId: 1 });
-
-  // Blocked collection indexes
-  await blockedCollection.createIndex({ userId: 1, url: 1 }, { unique: true });
-  await blockedCollection.createIndex({ userId: 1 });
-}

package/lib/storage/items.js

@@ -121,6 +121,73 @@ export function transformToJf2(item, userId) {
   return jf2;
 }
 
+/**
+ * Derive a favicon URL from a site or feed URL
+ * @param {string} url - Site or feed URL
+ * @returns {string|undefined} Favicon URL at the site origin
+ */
+function faviconUrl(url) {
+  try {
+    return new URL(url).origin + "/favicon.ico";
+  } catch {
+    return;
+  }
+}
+
+/**
+ * Enrich jf2 items with source identity (name, photo, url) from their feeds.
+ * Read-time join against microsub_feeds so existing items pick up feed
+ * metadata (title, channel image, site URL) without a migration, and stay
+ * fresh when a feed's metadata improves. Falls back to the site favicon
+ * when the feed has no image.
+ * @param {object} application - Indiekit application
+ * @param {Array<object>} items - jf2 items (mutated in place)
+ * @returns {Promise<Array<object>>} The same items, enriched
+ */
+export async function enrichItemsWithFeedSource(application, items) {
+  const feedIds = [
+    ...new Set(items.map((item) => item._feedId).filter(Boolean)),
+  ];
+  if (feedIds.length === 0) {
+    return items;
+  }
+
+  const feeds = await application.collections
+    .get("microsub_feeds")
+    .find({ _id: { $in: feedIds.map((id) => new ObjectId(id)) } })
+    .project({ title: 1, photo: 1, url: 1, siteUrl: 1 })
+    .toArray();
+  const feedsById = new Map(feeds.map((feed) => [feed._id.toString(), feed]));
+
+  for (const item of items) {
+    const feed = feedsById.get(item._feedId);
+    if (!feed) continue;
+
+    const siteUrl = feed.siteUrl || feed.url;
+    item._source = {
+      ...item._source,
+      name: feed.title || item._source?.name || safeHostname(siteUrl),
+      photo: feed.photo || faviconUrl(siteUrl),
+      url: siteUrl,
+    };
+  }
+
+  return items;
+}
+
+/**
+ * Extract hostname from a URL, or return the input on parse failure
+ * @param {string} url - URL string
+ * @returns {string} Hostname
+ */
+function safeHostname(url) {
+  try {
+    return new URL(url).hostname;
+  } catch {
+    return url;
+  }
+}
+
 /**
  * Add an item to a channel
  * @param {object} application - Indiekit application
@@ -218,6 +285,7 @@ export async function getTimelineItems(application, channelId, options = {}) {
 
   // Transform to jf2 format
   const jf2Items = items.map((item) => transformToJf2(item, options.userId));
+  await enrichItemsWithFeedSource(application, jf2Items);
 
   // Generate paging cursors
   const paging = generatePagingCursors(items, limit, hasMore, options.before);
@@ -282,6 +350,7 @@ export async function getAllTimelineItems(application, options = {}) {
   }
 
   const jf2Items = items.map((item) => transformToJf2(item, options.userId));
+  await enrichItemsWithFeedSource(application, jf2Items);
 
   const paging = generatePagingCursors(items, limit, hasMore, options.before);
 
@@ -320,21 +389,9 @@ export async function getItemById(application, id, userId) {
     return;
   }
 
-  return transformToJf2(item, userId);
-}
-
-/**
- * Get items by UIDs
- * @param {object} application - Indiekit application
- * @param {Array} uids - Array of item UIDs
- * @param {string} [userId] - User ID for read state
- * @returns {Promise<Array>} Array of jf2 items
- */
-export async function getItemsByUids(application, uids, userId) {
-  const collection = getCollection(application);
-
-  const items = await collection.find({ uid: { $in: uids } }).toArray();
-  return items.map((item) => transformToJf2(item, userId));
+  const jf2 = transformToJf2(item, userId);
+  await enrichItemsWithFeedSource(application, [jf2]);
+  return jf2;
 }
 
 /**

package/lib/utils/pagination.js

@@ -11,7 +11,7 @@ import { ObjectId } from "mongodb";
  * @param {string} id - Item ID
  * @returns {string} Base64-encoded cursor
  */
-export function encodeCursor(timestamp, id) {
+function encodeCursor(timestamp, id) {
   const data = {
     t: timestamp instanceof Date ? timestamp.toISOString() : timestamp,
     i: id.toString(),
@@ -24,7 +24,7 @@ export function encodeCursor(timestamp, id) {
  * @param {string} cursor - Base64-encoded cursor
  * @returns {object|null} Decoded cursor with timestamp and id
  */
-export function decodeCursor(cursor) {
+function decodeCursor(cursor) {
   if (!cursor) return;
 
   try {
@@ -133,15 +133,8 @@ export function generatePagingCursors(items, limit, hasMore, before) {
   return paging;
 }
 
-/**
- * Default pagination limit
- */
-export const DEFAULT_LIMIT = 20;
-
-/**
- * Maximum pagination limit
- */
-export const MAX_LIMIT = 100;
+const DEFAULT_LIMIT = 20;
+const MAX_LIMIT = 100;
 
 /**
  * Parse and validate limit parameter

package/lib/utils/validation.js

@@ -23,16 +23,6 @@ export const VALID_ACTIONS = [
   "events",
 ];
 
-/**
- * Valid channel methods
- */
-export const VALID_CHANNEL_METHODS = ["delete", "order"];
-
-/**
- * Valid timeline methods
- */
-export const VALID_TIMELINE_METHODS = ["mark_read", "mark_read_source", "mark_unread", "remove"];
-
 /**
  * Valid exclude types for channel filtering
  */

package/lib/webmention/processor.js

@@ -98,87 +98,6 @@ export async function processWebmention(application, source, target, userId) {
   };
 }
 
-/**
- * Delete a webmention (when source no longer links to target)
- * @param {object} application - Indiekit application
- * @param {string} source - Source URL
- * @param {string} target - Target URL
- * @returns {Promise<boolean>} Whether deletion was successful
- */
-export async function deleteWebmention(application, source, target) {
-  const collection = getCollection(application);
-  const result = await collection.deleteOne({ source, target });
-  return result.deletedCount > 0;
-}
-
-/**
- * Get notifications for a user
- * @param {object} application - Indiekit application
- * @param {string} userId - User ID
- * @param {object} options - Query options
- * @returns {Promise<Array>} Array of notifications
- */
-export async function getNotifications(application, userId, options = {}) {
-  const collection = getCollection(application);
-  const { limit = 20, unreadOnly = false } = options;
-
-  const query = { userId };
-  if (unreadOnly) {
-    query.readBy = { $ne: userId };
-  }
-
-  /* eslint-disable unicorn/no-array-callback-reference, unicorn/no-array-sort -- MongoDB cursor methods */
-  const notifications = await collection
-    .find(query)
-    .sort({ published: -1 })
-    .limit(limit)
-    .toArray();
-  /* eslint-enable unicorn/no-array-callback-reference, unicorn/no-array-sort */
-
-  return notifications.map((n) => transformNotification(n, userId));
-}
-
-/**
- * Mark notifications as read
- * @param {object} application - Indiekit application
- * @param {string} userId - User ID
- * @param {Array} ids - Notification IDs to mark as read
- * @returns {Promise<number>} Number of notifications updated
- */
-export async function markNotificationsRead(application, userId, ids) {
-  const collection = getCollection(application);
-  const { ObjectId } = await import("mongodb");
-
-  const objectIds = ids.map((id) => {
-    try {
-      return new ObjectId(id);
-    } catch {
-      return id;
-    }
-  });
-
-  const result = await collection.updateMany(
-    { _id: { $in: objectIds } },
-    { $addToSet: { readBy: userId } },
-  );
-
-  return result.modifiedCount;
-}
-
-/**
- * Get unread notification count
- * @param {object} application - Indiekit application
- * @param {string} userId - User ID
- * @returns {Promise<number>} Unread count
- */
-export async function getUnreadNotificationCount(application, userId) {
-  const collection = getCollection(application);
-  return collection.countDocuments({
-    userId,
-    readBy: { $ne: userId },
-  });
-}
-
 /**
  * Transform notification to API format
  * @param {object} notification - Database notification
@@ -200,15 +119,3 @@ function transformNotification(notification, userId) {
   };
 }
 
-/**
- * Create indexes for notifications
- * @param {object} application - Indiekit application
- * @returns {Promise<void>}
- */
-export async function createNotificationIndexes(application) {
-  const collection = getCollection(application);
-
-  await collection.createIndex({ userId: 1, published: -1 });
-  await collection.createIndex({ source: 1, target: 1 });
-  await collection.createIndex({ userId: 1, readBy: 1 });
-}

package/lib/websub/subscriber.js

@@ -165,23 +165,6 @@ export function verifySignature(signature, body, secret) {
   }
 }
 
-/**
- * Check if a WebSub subscription is about to expire
- * @param {object} feed - Feed document
- * @param {number} [thresholdSeconds] - Seconds before expiry to consider "expiring"
- * @returns {boolean} Whether subscription is expiring soon
- */
-export function isSubscriptionExpiring(feed, thresholdSeconds = 86_400) {
-  if (!feed.websub?.expiresAt) {
-    return false;
-  }
-
-  const expiresAt = new Date(feed.websub.expiresAt);
-  const threshold = new Date(Date.now() + thresholdSeconds * 1000);
-
-  return expiresAt <= threshold;
-}
-
 /**
  * Get callback URL for a feed
  * @param {string} baseUrl - Base URL of the Microsub endpoint

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rmdes/indiekit-endpoint-microsub",
-  "version": "1.0.64",
+  "version": "1.0.66",
   "description": "Microsub endpoint for Indiekit. Enables subscribing to feeds and reading content using the Microsub protocol.",
   "keywords": [
     "indiekit",
@@ -40,12 +40,9 @@
     "@rmdes/indiekit-startup-gate": "^1.0.0",
     "@indiekit/frontend": "^1.0.0-beta.25",
     "@indiekit/util": "^1.0.0-beta.25",
-    "debug": "^4.3.2",
     "express": "^5.0.0",
     "feedparser": "^2.2.10",
-    "htmlparser2": "^9.0.0",
     "ioredis": "^5.3.0",
-    "luxon": "^3.4.0",
     "microformats-parser": "^2.0.0",
     "express-rate-limit": "^7.0.0",
     "safe-regex2": "^4.0.0",

package/views/partials/item-card-compact.njk

@@ -18,7 +18,10 @@
       {% endif %}
       <div class="ms-item-card-compact__meta">
         {% if item._source %}
-        <span class="ms-item-card-compact__source">{{ item._source.name or item._source.url }}</span>
+        <span class="ms-item-card-compact__source">
+          {%- if item._source.photo %}<img src="{{ item._source.photo }}" alt="" class="ms-item-card-compact__favicon" width="16" height="16" loading="lazy"> {% endif -%}
+          {{- item._source.name or item._source.url -}}
+        </span>
         {% elif item.author %}
         <span class="ms-item-card-compact__source">{{ item.author.name }}</span>
         {% endif %}

package/views/partials/item-card.njk

@@ -50,25 +50,27 @@
   {% endif %}
 
   <a href="{{ baseUrl }}/item/{{ item._id }}" class="ms-item-card__link">
-    {# Author #}
-    {% if item.author %}
+    {# Author / source identity — prefer item author, fall back to feed source #}
+    {% set identityPhoto = item.author.photo or item._source.photo %}
+    {% set identityName = item.author.name or item._source.name %}
+    {% if identityName or identityPhoto %}
     <div class="ms-item-card__author">
       <div class="ms-item-card__avatar-wrap" data-avatar-fallback>
-        {% if item.author.photo %}
-        <img src="{{ item.author.photo }}"
+        {% if identityPhoto %}
+        <img src="{{ identityPhoto }}"
              alt=""
              class="ms-item-card__author-photo"
              width="40"
              height="40"
              loading="lazy">
         {% endif %}
-        <span class="ms-item-card__author-photo ms-item-card__author-photo--default" aria-hidden="true">{{ item.author.name[0] | upper if item.author.name else "?" }}</span>
+        <span class="ms-item-card__author-photo ms-item-card__author-photo--default" aria-hidden="true">{{ identityName[0] | upper if identityName else "?" }}</span>
       </div>
       <div class="ms-item-card__author-info">
-        <span class="ms-item-card__author-name">{{ item.author.name or "Unknown" }}</span>
-        {% if item._source %}
+        <span class="ms-item-card__author-name">{{ identityName or "Unknown" }}</span>
+        {% if item._source and (item._source.name or item._source.url) and item._source.name != identityName %}
         <span class="ms-item-card__source">{{ item._source.name or item._source.url }}</span>
-        {% elif item.author.url %}
+        {% elif item.author.url and item.author.name %}
         <span class="ms-item-card__source">{{ item.author.url | replace("https://", "") | replace("http://", "") }}</span>
         {% endif %}
       </div>