@rmdes/indiekit-endpoint-microsub 1.0.63 → 1.0.65

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}`,
   );
 
@@ -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/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/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/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.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/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));
-}

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