@rmdes/indiekit-endpoint-microsub 1.0.0-beta.1

package/lib/storage/filters.js

@@ -0,0 +1,265 @@
+/**
+ * Filter storage operations (mute, block, channel filters)
+ * @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
+ * @param {object} item - Feed item
+ * @param {object} settings - Channel settings
+ * @returns {boolean} Whether the item passes
+ */
+export function passesTypeFilter(item, settings) {
+  if (!settings.excludeTypes || settings.excludeTypes.length === 0) {
+    return true;
+  }
+
+  const itemType = detectInteractionType(item);
+  return !settings.excludeTypes.includes(itemType);
+}
+
+/**
+ * Check if an item passes the excludeRegex filter
+ * @param {object} item - Feed item
+ * @param {object} settings - Channel settings
+ * @returns {boolean} Whether the item passes
+ */
+export function passesRegexFilter(item, settings) {
+  if (!settings.excludeRegex) {
+    return true;
+  }
+
+  try {
+    const regex = new RegExp(settings.excludeRegex, "i");
+    const searchText = [
+      item.name,
+      item.summary,
+      item.content?.text,
+      item.content?.html,
+    ]
+      .filter(Boolean)
+      .join(" ");
+
+    return !regex.test(searchText);
+  } catch {
+    // Invalid regex, skip filter
+    return true;
+  }
+}
+
+/**
+ * Detect the interaction type of an item
+ * @param {object} item - Feed item
+ * @returns {string} Interaction type
+ */
+export function detectInteractionType(item) {
+  if (item["like-of"] && item["like-of"].length > 0) {
+    return "like";
+  }
+  if (item["repost-of"] && item["repost-of"].length > 0) {
+    return "repost";
+  }
+  if (item["bookmark-of"] && item["bookmark-of"].length > 0) {
+    return "bookmark";
+  }
+  if (item["in-reply-to"] && item["in-reply-to"].length > 0) {
+    return "reply";
+  }
+  if (item.rsvp) {
+    return "rsvp";
+  }
+  if (item.checkin) {
+    return "checkin";
+  }
+
+  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

@@ -0,0 +1,419 @@
+/**
+ * Timeline item storage operations
+ * @module storage/items
+ */
+
+import { ObjectId } from "mongodb";
+
+import {
+  buildPaginationQuery,
+  buildPaginationSort,
+  generatePagingCursors,
+  parseLimit,
+} from "../utils/pagination.js";
+
+/**
+ * Get items collection from application
+ * @param {object} application - Indiekit application
+ * @returns {object} MongoDB collection
+ */
+function getCollection(application) {
+  return application.collections.get("microsub_items");
+}
+
+/**
+ * Add an item to a channel
+ * @param {object} application - Indiekit application
+ * @param {object} data - Item data
+ * @param {ObjectId} data.channelId - Channel ObjectId
+ * @param {ObjectId} data.feedId - Feed ObjectId
+ * @param {string} data.uid - Unique item identifier
+ * @param {object} data.item - jf2 item data
+ * @returns {Promise<object|null>} Created item or null if duplicate
+ */
+export async function addItem(application, { channelId, feedId, uid, item }) {
+  const collection = getCollection(application);
+
+  // Check for duplicate
+  const existing = await collection.findOne({ channelId, uid });
+  if (existing) {
+    return; // Duplicate, don't add
+  }
+
+  const document = {
+    channelId,
+    feedId,
+    uid,
+    type: item.type || "entry",
+    url: item.url,
+    name: item.name || undefined,
+    content: item.content || undefined,
+    summary: item.summary || undefined,
+    published: item.published ? new Date(item.published) : new Date(),
+    updated: item.updated ? new Date(item.updated) : undefined,
+    author: item.author || undefined,
+    category: item.category || [],
+    photo: item.photo || [],
+    video: item.video || [],
+    audio: item.audio || [],
+    likeOf: item["like-of"] || item.likeOf || [],
+    repostOf: item["repost-of"] || item.repostOf || [],
+    bookmarkOf: item["bookmark-of"] || item.bookmarkOf || [],
+    inReplyTo: item["in-reply-to"] || item.inReplyTo || [],
+    source: item._source || undefined,
+    readBy: [], // Array of user IDs who have read this item
+    createdAt: new Date(),
+  };
+
+  await collection.insertOne(document);
+  return document;
+}
+
+/**
+ * Get timeline items for a channel
+ * @param {object} application - Indiekit application
+ * @param {ObjectId|string} channelId - Channel ObjectId
+ * @param {object} options - Query options
+ * @param {string} [options.before] - Before cursor
+ * @param {string} [options.after] - After cursor
+ * @param {number} [options.limit] - Items per page
+ * @param {string} [options.userId] - User ID for read state
+ * @returns {Promise<object>} Timeline with items and paging
+ */
+export async function getTimelineItems(application, channelId, options = {}) {
+  const collection = getCollection(application);
+  const objectId =
+    typeof channelId === "string" ? new ObjectId(channelId) : channelId;
+  const limit = parseLimit(options.limit);
+
+  const baseQuery = { channelId: objectId };
+  const query = buildPaginationQuery({
+    before: options.before,
+    after: options.after,
+    baseQuery,
+  });
+
+  const sort = buildPaginationSort(options.before);
+
+  // Fetch one extra to check if there are more
+  const items = await collection
+    // eslint-disable-next-line unicorn/no-array-callback-reference -- query is MongoDB query object
+    .find(query)
+    .toSorted(sort)
+    .limit(limit + 1)
+    .toArray();
+
+  const hasMore = items.length > limit;
+  if (hasMore) {
+    items.pop();
+  }
+
+  // Transform to jf2 format
+  const jf2Items = items.map((item) => transformToJf2(item, options.userId));
+
+  // Generate paging cursors
+  const paging = generatePagingCursors(items, limit, hasMore, options.before);
+
+  return {
+    items: jf2Items,
+    paging,
+  };
+}
+
+/**
+ * Transform database item to jf2 format
+ * @param {object} item - Database item
+ * @param {string} [userId] - User ID for read state
+ * @returns {object} jf2 item
+ */
+function transformToJf2(item, userId) {
+  const jf2 = {
+    type: item.type,
+    uid: item.uid,
+    url: item.url,
+    published: item.published?.toISOString(),
+    _id: item._id.toString(),
+    _is_read: userId ? item.readBy?.includes(userId) : false,
+  };
+
+  // Optional fields
+  if (item.name) jf2.name = item.name;
+  if (item.content) jf2.content = item.content;
+  if (item.summary) jf2.summary = item.summary;
+  if (item.updated) jf2.updated = item.updated.toISOString();
+  if (item.author) jf2.author = item.author;
+  if (item.category?.length > 0) jf2.category = item.category;
+  if (item.photo?.length > 0) jf2.photo = item.photo;
+  if (item.video?.length > 0) jf2.video = item.video;
+  if (item.audio?.length > 0) jf2.audio = item.audio;
+
+  // Interaction types
+  if (item.likeOf?.length > 0) jf2["like-of"] = item.likeOf;
+  if (item.repostOf?.length > 0) jf2["repost-of"] = item.repostOf;
+  if (item.bookmarkOf?.length > 0) jf2["bookmark-of"] = item.bookmarkOf;
+  if (item.inReplyTo?.length > 0) jf2["in-reply-to"] = item.inReplyTo;
+
+  // Source
+  if (item.source) jf2._source = item.source;
+
+  return jf2;
+}
+
+/**
+ * Get an item by ID
+ * @param {object} application - Indiekit application
+ * @param {ObjectId|string} id - Item ObjectId
+ * @param {string} [userId] - User ID for read state
+ * @returns {Promise<object|null>} jf2 item or null
+ */
+export async function getItemById(application, id, userId) {
+  const collection = getCollection(application);
+  const objectId = typeof id === "string" ? new ObjectId(id) : id;
+
+  const item = await collection.findOne({ _id: objectId });
+  if (!item) 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));
+}
+
+/**
+ * Mark items as read
+ * @param {object} application - Indiekit application
+ * @param {ObjectId|string} channelId - Channel ObjectId
+ * @param {Array} entryIds - Array of entry IDs to mark as read
+ * @param {string} userId - User ID
+ * @returns {Promise<number>} Number of items updated
+ */
+export async function markItemsRead(application, channelId, entryIds, userId) {
+  const collection = getCollection(application);
+  const channelObjectId =
+    typeof channelId === "string" ? new ObjectId(channelId) : channelId;
+
+  // Handle "last-read-entry" special value
+  if (entryIds.includes("last-read-entry")) {
+    // Mark all items in channel as read
+    const result = await collection.updateMany(
+      { channelId: channelObjectId },
+      { $addToSet: { readBy: userId } },
+    );
+    return result.modifiedCount;
+  }
+
+  // Convert string IDs to ObjectIds where possible
+  const objectIds = entryIds.map((id) => {
+    try {
+      return new ObjectId(id);
+    } catch {
+      return id;
+    }
+  });
+
+  const result = await collection.updateMany(
+    {
+      channelId: channelObjectId,
+      $or: [{ _id: { $in: objectIds } }, { uid: { $in: entryIds } }],
+    },
+    { $addToSet: { readBy: userId } },
+  );
+
+  return result.modifiedCount;
+}
+
+/**
+ * Mark items as unread
+ * @param {object} application - Indiekit application
+ * @param {ObjectId|string} channelId - Channel ObjectId
+ * @param {Array} entryIds - Array of entry IDs to mark as unread
+ * @param {string} userId - User ID
+ * @returns {Promise<number>} Number of items updated
+ */
+export async function markItemsUnread(
+  application,
+  channelId,
+  entryIds,
+  userId,
+) {
+  const collection = getCollection(application);
+  const channelObjectId =
+    typeof channelId === "string" ? new ObjectId(channelId) : channelId;
+
+  const objectIds = entryIds.map((id) => {
+    try {
+      return new ObjectId(id);
+    } catch {
+      return id;
+    }
+  });
+
+  const result = await collection.updateMany(
+    {
+      channelId: channelObjectId,
+      $or: [{ _id: { $in: objectIds } }, { uid: { $in: entryIds } }],
+    },
+    { $pull: { readBy: userId } },
+  );
+
+  return result.modifiedCount;
+}
+
+/**
+ * Remove items from channel
+ * @param {object} application - Indiekit application
+ * @param {ObjectId|string} channelId - Channel ObjectId
+ * @param {Array} entryIds - Array of entry IDs to remove
+ * @returns {Promise<number>} Number of items removed
+ */
+export async function removeItems(application, channelId, entryIds) {
+  const collection = getCollection(application);
+  const channelObjectId =
+    typeof channelId === "string" ? new ObjectId(channelId) : channelId;
+
+  const objectIds = entryIds.map((id) => {
+    try {
+      return new ObjectId(id);
+    } catch {
+      return id;
+    }
+  });
+
+  const result = await collection.deleteMany({
+    channelId: channelObjectId,
+    $or: [{ _id: { $in: objectIds } }, { uid: { $in: entryIds } }],
+  });
+
+  return result.deletedCount;
+}
+
+/**
+ * Delete all items for a channel
+ * @param {object} application - Indiekit application
+ * @param {ObjectId|string} channelId - Channel ObjectId
+ * @returns {Promise<number>} Number of deleted items
+ */
+export async function deleteItemsForChannel(application, channelId) {
+  const collection = getCollection(application);
+  const objectId =
+    typeof channelId === "string" ? new ObjectId(channelId) : channelId;
+
+  const result = await collection.deleteMany({ channelId: objectId });
+  return result.deletedCount;
+}
+
+/**
+ * Delete items for a specific feed
+ * @param {object} application - Indiekit application
+ * @param {ObjectId|string} feedId - Feed ObjectId
+ * @returns {Promise<number>} Number of deleted items
+ */
+export async function deleteItemsForFeed(application, feedId) {
+  const collection = getCollection(application);
+  const objectId = typeof feedId === "string" ? new ObjectId(feedId) : feedId;
+
+  const result = await collection.deleteMany({ feedId: objectId });
+  return result.deletedCount;
+}
+
+/**
+ * Get unread count for a channel
+ * @param {object} application - Indiekit application
+ * @param {ObjectId|string} channelId - Channel ObjectId
+ * @param {string} userId - User ID
+ * @returns {Promise<number>} Unread count
+ */
+export async function getUnreadCount(application, channelId, userId) {
+  const collection = getCollection(application);
+  const objectId =
+    typeof channelId === "string" ? new ObjectId(channelId) : channelId;
+
+  return collection.countDocuments({
+    channelId: objectId,
+    readBy: { $ne: userId },
+  });
+}
+
+/**
+ * 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 regex search (consider adding text index for better performance)
+  const regex = new RegExp(query, "i");
+  const items = await collection
+    .find({
+      channelId: objectId,
+      $or: [
+        { name: regex },
+        { "content.text": regex },
+        { "content.html": regex },
+        { summary: regex },
+      ],
+    })
+    .toSorted({ published: -1 })
+    .limit(limit)
+    .toArray();
+
+  return items.map((item) => transformToJf2(item));
+}
+
+/**
+ * Delete items by author URL (for blocking)
+ * @param {object} application - Indiekit application
+ * @param {string} userId - User ID (for filtering user's channels)
+ * @param {string} authorUrl - Author URL to delete items from
+ * @returns {Promise<number>} Number of deleted items
+ */
+export async function deleteItemsByAuthorUrl(application, userId, authorUrl) {
+  const collection = getCollection(application);
+  const channelsCollection = application.collections.get("microsub_channels");
+
+  // Get all channel IDs for this user
+  const userChannels = await channelsCollection.find({ userId }).toArray();
+  const channelIds = userChannels.map((c) => c._id);
+
+  // Delete all items from blocked author in user's channels
+  const result = await collection.deleteMany({
+    channelId: { $in: channelIds },
+    "author.url": authorUrl,
+  });
+
+  return result.deletedCount;
+}
+
+/**
+ * Create indexes for efficient queries
+ * @param {object} application - Indiekit application
+ * @returns {Promise<void>}
+ */
+export async function createIndexes(application) {
+  const collection = getCollection(application);
+
+  await collection.createIndex({ channelId: 1, published: -1 });
+  await collection.createIndex({ channelId: 1, uid: 1 }, { unique: true });
+  await collection.createIndex({ feedId: 1 });
+  await collection.createIndex(
+    { name: "text", "content.text": "text", summary: "text" },
+    { name: "text_search" },
+  );
+}