@rmdes/indiekit-endpoint-microsub 1.0.64 → 1.0.65

package/lib/cache/redis.js

@@ -119,24 +119,6 @@ export async function setCache(redis, key, value, ttl = 300) {
   }
 }
 
-/**
- * Delete value from cache
- * @param {object} redis - Redis client
- * @param {string} key - Cache key
- * @returns {Promise<void>}
- */
-export async function deleteCache(redis, key) {
-  if (!redis) {
-    return;
-  }
-
-  try {
-    await redis.del(nsKey(key));
-  } catch {
-    // Ignore cache errors
-  }
-}
-
 /**
  * Publish event to channel
  * @param {object} redis - Redis client
@@ -185,16 +167,3 @@ export async function subscribeToChannel(redis, channel, callback) {
   }
 }
 
-/**
- * Cleanup Redis connection on shutdown
- */
-export async function closeRedis() {
-  if (redisClient) {
-    try {
-      await redisClient.quit();
-      redisClient = undefined;
-    } catch {
-      // Ignore cleanup errors
-    }
-  }
-}

package/lib/controllers/block.js

@@ -82,5 +82,3 @@ export async function unblock(request, response) {
 
   response.json({ result: "ok" });
 }
-
-export const blockController = { list, block, unblock };

package/lib/controllers/channels.js

@@ -132,5 +132,3 @@ export async function get(request, response) {
     settings: channel.settings,
   });
 }
-
-export const channelsController = { list, action, get };

package/lib/controllers/events.js

@@ -53,5 +53,3 @@ export async function stream(request, response) {
     removeClient(response);
   });
 }
-
-export const eventsController = { stream };

package/lib/controllers/follow.js

@@ -163,5 +163,3 @@ export async function unfollow(request, response) {
 
   response.json({ result: "ok" });
 }
-
-export const followController = { list, follow, unfollow };

package/lib/controllers/mute.js

@@ -121,5 +121,3 @@ export async function unmute(request, response) {
 
   response.json({ result: "ok" });
 }
-
-export const muteController = { list, mute, unmute };

package/lib/controllers/preview.js

@@ -63,5 +63,3 @@ export async function preview(request, response) {
   const previewData = await fetchPreview(url);
   response.json(previewData);
 }
-
-export const previewController = { get, preview };

package/lib/controllers/reader/index.js

@@ -1,45 +1,9 @@
 /**
- * Reader controller - barrel re-export
+ * Reader controller aggregator. Bundles handlers from sibling modules into the
+ * `readerController` object consumed by route wiring in the plugin root.
  * @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 { deck, deckSettings, saveDeckSettings } from "./deck.js";
-
 import {
   index,
   channels,

package/lib/controllers/search.js

@@ -145,5 +145,3 @@ export async function search(request, response) {
     return response.json({ results: [] });
   }
 }
-
-export const searchController = { discover, search };

package/lib/controllers/timeline.js

@@ -150,5 +150,3 @@ export async function action(request, response) {
     }
   }
 }
-
-export const timelineController = { get, action };

package/lib/feeds/discovery.js

@@ -78,7 +78,7 @@ export async function discoverAndValidateFeeds(url) {
  * @param {Array} feeds - Array of feed objects
  * @returns {Array} Filtered array of main content feeds
  */
-export function filterMainFeeds(feeds) {
+function filterMainFeeds(feeds) {
   return feeds.filter((feed) => feed.valid && !feed.isCommentsFeed);
 }
 

package/lib/feeds/normalizer.js

@@ -30,7 +30,7 @@ export function generateItemUid(feedUrl, itemId) {
  * @param {string|Date} dateInput - Date string or Date object
  * @returns {Date|undefined} Parsed Date or undefined if invalid
  */
-export function parseDate(dateInput) {
+function parseDate(dateInput) {
   if (!dateInput) {
     return;
   }
@@ -108,7 +108,7 @@ export function extractPhotoUrl(photo) {
  * @param {object|string} value - URL string or object with url/value property
  * @returns {string|undefined} URL string
  */
-export function extractUrl(value) {
+function extractUrl(value) {
   if (!value) {
     return;
   }

package/lib/media/proxy.js

@@ -98,7 +98,7 @@ const ALLOWED_TYPES = new Set([
  * @param {string} url - Original image URL
  * @returns {string} URL-safe hash
  */
-export function hashUrl(url) {
+function hashUrl(url) {
   return crypto.createHash("sha256").update(url).digest("hex").slice(0, 16);
 }
 
@@ -107,7 +107,7 @@ export function hashUrl(url) {
  * @param {string} url - Original image URL
  * @returns {string} HMAC hex signature (16 chars)
  */
-export function signProxyUrl(url) {
+function signProxyUrl(url) {
   const secret = process.env.SECRET || "microsub-default-secret";
   return crypto
     .createHmac("sha256", secret)
@@ -122,7 +122,7 @@ export function signProxyUrl(url) {
  * @param {string} sig - Submitted signature
  * @returns {boolean} Whether signature is valid
  */
-export function verifyProxySignature(url, sig) {
+function verifyProxySignature(url, sig) {
   if (!sig) return false;
   const expected = signProxyUrl(url);
   // Constant-time comparison
@@ -136,7 +136,7 @@ export function verifyProxySignature(url, sig) {
  * @param {string} originalUrl - Original image URL
  * @returns {string} Proxied URL
  */
-export function getProxiedUrl(baseUrl, originalUrl) {
+function getProxiedUrl(baseUrl, originalUrl) {
   if (!originalUrl || !baseUrl) {
     return originalUrl;
   }
@@ -203,7 +203,7 @@ export function proxyItemImages(item, baseUrl) {
  * @param {string} url - Image URL to fetch
  * @returns {Promise<object|null>} Cached image data or null
  */
-export async function fetchImage(redis, url) {
+async function fetchImage(redis, url) {
   // Block private/internal URLs (defense-in-depth)
   if (await isPrivateUrl(url)) {
     console.error(`[Microsub] Media proxy blocked private URL: ${url}`);

package/lib/polling/scheduler.js

@@ -118,13 +118,3 @@ export async function refreshFeedNow(application, feedId) {
   return processFeed(application, feed);
 }
 
-/**
- * Get scheduler status
- * @returns {object} Scheduler status
- */
-export function getSchedulerStatus() {
-  return {
-    running: !!schedulerInterval,
-    processing: isRunning,
-  };
-}

package/lib/polling/tier.js

@@ -23,22 +23,24 @@ const MAX_TIER = 10;
 const DEFAULT_TIER = 1;
 
 /**
- * Get polling interval for a tier in milliseconds
+ * Get polling interval for a tier in milliseconds.
+ * Internal helper for getNextFetchTime.
  * @param {number} tier - Polling tier (0-10)
  * @returns {number} Interval in milliseconds
  */
-export function getIntervalForTier(tier) {
+function getIntervalForTier(tier) {
   const clampedTier = Math.max(MIN_TIER, Math.min(MAX_TIER, tier));
   const minutes = Math.pow(2, clampedTier);
   return minutes * 60 * 1000;
 }
 
 /**
- * Get next fetch time based on tier
+ * Get next fetch time based on tier.
+ * Internal helper for calculateNewTier.
  * @param {number} tier - Polling tier
  * @returns {Date} Next fetch time
  */
-export function getNextFetchTime(tier) {
+function getNextFetchTime(tier) {
   const interval = getIntervalForTier(tier);
   return new Date(Date.now() + interval);
 }
@@ -90,50 +92,3 @@ export function calculateNewTier(options) {
   };
 }
 
-/**
- * Get initial tier for a new feed subscription
- * @returns {object} Initial tier settings
- */
-export function getInitialTier() {
-  return {
-    tier: MIN_TIER, // Start at tier 0 for immediate first fetch
-    consecutiveUnchanged: 0,
-    nextFetchAt: new Date(), // Fetch immediately
-  };
-}
-
-/**
- * Determine if a feed is due for fetching
- * @param {object} feed - Feed document
- * @returns {boolean} Whether the feed should be fetched
- */
-export function isDueForFetch(feed) {
-  if (!feed.nextFetchAt) {
-    return true;
-  }
-
-  return new Date(feed.nextFetchAt) <= new Date();
-}
-
-/**
- * Get human-readable description of polling interval
- * @param {number} tier - Polling tier
- * @returns {string} Description
- */
-export function getTierDescription(tier) {
-  const minutes = Math.pow(2, tier);
-
-  if (minutes < 60) {
-    return `every ${minutes} minute${minutes === 1 ? "" : "s"}`;
-  }
-
-  const hours = minutes / 60;
-  if (hours < 24) {
-    return `every ${hours.toFixed(1)} hour${hours === 1 ? "" : "s"}`;
-  }
-
-  const days = hours / 24;
-  return `every ${days.toFixed(1)} day${days === 1 ? "" : "s"}`;
-}
-
-export { MIN_TIER, MAX_TIER, DEFAULT_TIER };

package/lib/realtime/broker.js

@@ -84,18 +84,6 @@ export function subscribeClient(response, channelId) {
   }
 }
 
-/**
- * Unsubscribe a client from a channel
- * @param {object} response - Express response object
- * @param {string} channelId - Channel ID
- */
-export function unsubscribeClient(response, channelId) {
-  const client = clients.get(response);
-  if (client) {
-    client.channels.delete(channelId);
-  }
-}
-
 /**
  * Send an event to a specific client
  * @param {object} response - Express response object
@@ -113,26 +101,13 @@ export function sendEvent(response, event, data) {
 }
 
 /**
- * Broadcast an event to all clients subscribed to a channel
- * @param {string} channelId - Channel ID
- * @param {string} event - Event name
- * @param {object} data - Event data
- */
-export function broadcastToChannel(channelId, event, data) {
-  for (const client of clients.values()) {
-    if (client.channels.has(channelId)) {
-      sendEvent(client.response, event, data);
-    }
-  }
-}
-
-/**
- * Broadcast an event to all clients for a user
+ * Broadcast an event to all clients for a user.
+ * Internal helper — only invoked by the Redis fan-out in handleRedisEvent.
  * @param {string} userId - User ID
  * @param {string} event - Event name
  * @param {object} data - Event data
  */
-export function broadcastToUser(userId, event, data) {
+function broadcastToUser(userId, event, data) {
   for (const client of clients.values()) {
     if (client.userId === userId) {
       sendEvent(client.response, event, data);
@@ -140,17 +115,6 @@ export function broadcastToUser(userId, event, data) {
   }
 }
 
-/**
- * Broadcast an event to all connected clients
- * @param {string} event - Event name
- * @param {object} data - Event data
- */
-export function broadcastToAll(event, data) {
-  for (const client of clients.values()) {
-    sendEvent(client.response, event, data);
-  }
-}
-
 /**
  * Set up Redis subscription for a user
  * @param {string} userId - User ID
@@ -208,39 +172,3 @@ function handleRedisEvent(userId, data) {
   }
 }
 
-/**
- * Get broker statistics
- * @returns {object} Statistics
- */
-export function getStats() {
-  const userCounts = new Map();
-  for (const client of clients.values()) {
-    const count = userCounts.get(client.userId) || 0;
-    userCounts.set(client.userId, count + 1);
-  }
-
-  return {
-    totalClients: clients.size,
-    uniqueUsers: userCounts.size,
-    userSubscribers: userSubscribers.size,
-  };
-}
-
-/**
- * Clean up all connections
- */
-export function cleanup() {
-  for (const client of clients.values()) {
-    clearInterval(client.pingInterval);
-  }
-  clients.clear();
-
-  for (const subscriber of userSubscribers.values()) {
-    try {
-      subscriber.quit();
-    } catch {
-      // Ignore cleanup errors
-    }
-  }
-  userSubscribers.clear();
-}

package/lib/storage/channels.js

@@ -29,7 +29,7 @@ const CHANNEL_COLORS = [
  * @param {number} order - Channel order index
  * @returns {string} Hex color
  */
-export function getChannelColor(order) {
+function getChannelColor(order) {
   return CHANNEL_COLORS[Math.abs(order) % CHANNEL_COLORS.length];
 }
 

package/lib/storage/feeds.js

@@ -45,7 +45,7 @@ export function normalizeUrl(url) {
  * @param {string} url - Feed URL to check
  * @returns {Promise<object|null>} Existing feed with channel info, or null
  */
-export async function findFeedAcrossChannels(application, url) {
+async function findFeedAcrossChannels(application, url) {
   const collection = getCollection(application);
   const normalized = normalizeUrl(url);
 
@@ -427,19 +427,3 @@ export async function updateFeedStatus(application, id, status) {
   });
 }
 
-/**
- * Get feeds with errors
- * @param {object} application - Indiekit application
- * @param {number} [minErrors=3] - Minimum consecutive errors
- * @returns {Promise<Array>} Array of feeds with errors
- */
-export async function getFeedsWithErrors(application, minErrors = 3) {
-  const collection = getCollection(application);
-
-  return collection
-    .find({
-      status: "error",
-      consecutiveErrors: { $gte: minErrors },
-    })
-    .toArray();
-}

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

@@ -323,20 +323,6 @@ export async function getItemById(application, id, userId) {
   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));
-}
-
 /**
  * Remove items from channel
  * @param {object} application - Indiekit application

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.65",
   "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/lib/storage/read-state.js

@@ -1,109 +0,0 @@
-/**
- * Read state tracking utilities
- * @module storage/read-state
- */
-
-import { markItemsRead, markItemsUnread, getUnreadCount } from "./items-read-state.js";
-
-/**
- * Mark entries as read for a user
- * @param {object} application - Indiekit application
- * @param {string} channelUid - Channel UID
- * @param {Array} entries - Entry IDs to mark as read
- * @param {string} userId - User ID
- * @returns {Promise<number>} Number of entries marked
- */
-export async function markRead(application, channelUid, entries, userId) {
-  const channelsCollection = application.collections.get("microsub_channels");
-  const channel = await channelsCollection.findOne({ uid: channelUid });
-
-  if (!channel) {
-    return 0;
-  }
-
-  return markItemsRead(application, channel._id, entries, userId);
-}
-
-/**
- * Mark entries as unread for a user
- * @param {object} application - Indiekit application
- * @param {string} channelUid - Channel UID
- * @param {Array} entries - Entry IDs to mark as unread
- * @param {string} userId - User ID
- * @returns {Promise<number>} Number of entries marked
- */
-export async function markUnread(application, channelUid, entries, userId) {
-  const channelsCollection = application.collections.get("microsub_channels");
-  const channel = await channelsCollection.findOne({ uid: channelUid });
-
-  if (!channel) {
-    return 0;
-  }
-
-  return markItemsUnread(application, channel._id, entries, userId);
-}
-
-/**
- * Get unread count for a channel
- * @param {object} application - Indiekit application
- * @param {string} channelUid - Channel UID
- * @param {string} userId - User ID
- * @returns {Promise<number>} Unread count
- */
-export async function getChannelUnreadCount(application, channelUid, userId) {
-  const channelsCollection = application.collections.get("microsub_channels");
-  const channel = await channelsCollection.findOne({ uid: channelUid });
-
-  if (!channel) {
-    return 0;
-  }
-
-  return getUnreadCount(application, channel._id, userId);
-}
-
-/**
- * Get unread counts for all channels
- * @param {object} application - Indiekit application
- * @param {string} userId - User ID
- * @returns {Promise<Map>} Map of channel UID to unread count
- */
-export async function getAllUnreadCounts(application, userId) {
-  const channelsCollection = application.collections.get("microsub_channels");
-  const itemsCollection = application.collections.get("microsub_items");
-
-  // Aggregate unread counts per channel
-  const pipeline = [
-    {
-      $match: {
-        readBy: { $ne: userId },
-      },
-    },
-    {
-      $group: {
-        _id: "$channelId",
-        count: { $sum: 1 },
-      },
-    },
-  ];
-
-  const results = await itemsCollection.aggregate(pipeline).toArray();
-
-  // Get channel UIDs
-  const channelIds = results.map((r) => r._id);
-  const channels = await channelsCollection
-    .find({ _id: { $in: channelIds } })
-    .toArray();
-
-  const channelMap = new Map(channels.map((c) => [c._id.toString(), c.uid]));
-
-  // Build result map
-  const unreadCounts = new Map();
-  for (const result of results) {
-    const uid = channelMap.get(result._id.toString());
-    if (uid) {
-      unreadCounts.set(uid, result.count);
-    }
-  }
-
-  return unreadCounts;
-}

package/lib/websub/discovery.js

@@ -1,129 +0,0 @@
-/**
- * WebSub hub discovery
- * @module websub/discovery
- */
-
-/**
- * Discover WebSub hub from HTTP response headers and content
- * @param {object} response - Fetch response object
- * @param {string} content - Response body content
- * @returns {object|undefined} WebSub info { hub, self }
- */
-export function discoverWebsub(response, content) {
-  // Try to find hub and self URLs from Link headers first
-  const linkHeader = response.headers.get("link");
-  const fromHeaders = linkHeader ? parseLinkHeader(linkHeader) : {};
-
-  // Fall back to content parsing
-  const fromContent = parseContentForLinks(content);
-
-  const hub = fromHeaders.hub || fromContent.hub;
-  const self = fromHeaders.self || fromContent.self;
-
-  if (hub) {
-    return { hub, self };
-  }
-
-  return;
-}
-
-/**
- * Parse Link header for hub and self URLs
- * @param {string} linkHeader - Link header value
- * @returns {object} { hub, self }
- */
-function parseLinkHeader(linkHeader) {
-  const result = {};
-  const links = linkHeader.split(",");
-
-  for (const link of links) {
-    const parts = link.trim().split(";");
-    if (parts.length < 2) continue;
-
-    const urlMatch = parts[0].match(/<([^>]+)>/);
-    if (!urlMatch) continue;
-
-    const url = urlMatch[1];
-    const relationship = parts
-      .slice(1)
-      .find((p) => p.trim().startsWith("rel="))
-      ?.match(/rel=["']?([^"'\s;]+)["']?/)?.[1];
-
-    if (relationship === "hub") {
-      result.hub = url;
-    } else if (relationship === "self") {
-      result.self = url;
-    }
-  }
-
-  return result;
-}
-
-/**
- * Parse content for hub and self URLs (Atom, RSS, HTML)
- * @param {string} content - Response body
- * @returns {object} { hub, self }
- */
-function parseContentForLinks(content) {
-  const result = {};
-
-  // Try HTML <link> elements
-  const htmlHubMatch = content.match(
-    /<link[^>]+rel=["']?hub["']?[^>]+href=["']([^"']+)["']/i,
-  );
-  if (htmlHubMatch) {
-    result.hub = htmlHubMatch[1];
-  }
-
-  const htmlSelfMatch = content.match(
-    /<link[^>]+rel=["']?self["']?[^>]+href=["']([^"']+)["']/i,
-  );
-  if (htmlSelfMatch) {
-    result.self = htmlSelfMatch[1];
-  }
-
-  // Also try the reverse order (href before rel)
-  if (!result.hub) {
-    const htmlHubMatch2 = content.match(
-      /<link[^>]+href=["']([^"']+)["'][^>]+rel=["']?hub["']?/i,
-    );
-    if (htmlHubMatch2) {
-      result.hub = htmlHubMatch2[1];
-    }
-  }
-
-  if (!result.self) {
-    const htmlSelfMatch2 = content.match(
-      /<link[^>]+href=["']([^"']+)["'][^>]+rel=["']?self["']?/i,
-    );
-    if (htmlSelfMatch2) {
-      result.self = htmlSelfMatch2[1];
-    }
-  }
-
-  // Try Atom <link> elements
-  if (!result.hub) {
-    const atomHubMatch = content.match(
-      /<atom:link[^>]+rel=["']?hub["']?[^>]+href=["']([^"']+)["']/i,
-    );
-    if (atomHubMatch) {
-      result.hub = atomHubMatch[1];
-    }
-  }
-
-  return result;
-}
-
-/**
- * Check if a hub URL is valid
- * @param {string} hubUrl - Hub URL to validate
- * @returns {boolean} Whether the URL is valid
- */
-export function isValidHubUrl(hubUrl) {
-  try {
-    const url = new URL(hubUrl);
-    return url.protocol === "https:" || url.protocol === "http:";
-  } catch {
-    return false;
-  }
-}