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

package/lib/storage/channels.js

@@ -0,0 +1,281 @@
+/**
+ * Channel storage operations
+ * @module storage/channels
+ */
+
+import { ObjectId } from "mongodb";
+
+import { generateChannelUid } from "../utils/jf2.js";
+
+/**
+ * Get channels collection from application
+ * @param {object} application - Indiekit application
+ * @returns {object} MongoDB collection
+ */
+function getCollection(application) {
+  return application.collections.get("microsub_channels");
+}
+
+/**
+ * Get items collection for unread counts
+ * @param {object} application - Indiekit application
+ * @returns {object} MongoDB collection
+ */
+function getItemsCollection(application) {
+  return application.collections.get("microsub_items");
+}
+
+/**
+ * Create a new channel
+ * @param {object} application - Indiekit application
+ * @param {object} data - Channel data
+ * @param {string} data.name - Channel name
+ * @param {string} [data.userId] - User ID
+ * @returns {Promise<object>} Created channel
+ */
+export async function createChannel(application, { name, userId }) {
+  const collection = getCollection(application);
+
+  // Generate unique UID with retry on collision
+  let uid;
+  let attempts = 0;
+  const maxAttempts = 5;
+
+  while (attempts < maxAttempts) {
+    uid = generateChannelUid();
+    const existing = await collection.findOne({ uid });
+    if (!existing) break;
+    attempts++;
+  }
+
+  if (attempts >= maxAttempts) {
+    throw new Error("Failed to generate unique channel UID");
+  }
+
+  // Get max order for user
+  const maxOrderResult = await collection
+    .find({ userId })
+    .toSorted({ order: -1 })
+    .limit(1)
+    .toArray();
+
+  const order = maxOrderResult.length > 0 ? maxOrderResult[0].order + 1 : 0;
+
+  const channel = {
+    uid,
+    name,
+    userId,
+    order,
+    settings: {
+      excludeTypes: [],
+      excludeRegex: undefined,
+    },
+    createdAt: new Date(),
+    updatedAt: new Date(),
+  };
+
+  await collection.insertOne(channel);
+
+  return channel;
+}
+
+/**
+ * Get all channels for a user
+ * @param {object} application - Indiekit application
+ * @param {string} [userId] - User ID (optional for single-user mode)
+ * @returns {Promise<Array>} Array of channels with unread counts
+ */
+export async function getChannels(application, userId) {
+  const collection = getCollection(application);
+  const itemsCollection = getItemsCollection(application);
+
+  const filter = userId ? { userId } : {};
+  const channels = await collection
+    // eslint-disable-next-line unicorn/no-array-callback-reference -- filter is MongoDB query object
+    .find(filter)
+    .toSorted({ order: 1 })
+    .toArray();
+
+  // Get unread counts for each channel
+  const channelsWithCounts = await Promise.all(
+    channels.map(async (channel) => {
+      const unreadCount = await itemsCollection.countDocuments({
+        channelId: channel._id,
+        readBy: { $ne: userId },
+      });
+
+      return {
+        uid: channel.uid,
+        name: channel.name,
+        unread: unreadCount > 0 ? unreadCount : false,
+      };
+    }),
+  );
+
+  // Always include notifications channel first
+  const notificationsChannel = channelsWithCounts.find(
+    (c) => c.uid === "notifications",
+  );
+  const otherChannels = channelsWithCounts.filter(
+    (c) => c.uid !== "notifications",
+  );
+
+  if (notificationsChannel) {
+    return [notificationsChannel, ...otherChannels];
+  }
+
+  return channelsWithCounts;
+}
+
+/**
+ * Get a single channel by UID
+ * @param {object} application - Indiekit application
+ * @param {string} uid - Channel UID
+ * @param {string} [userId] - User ID
+ * @returns {Promise<object|null>} Channel or null
+ */
+export async function getChannel(application, uid, userId) {
+  const collection = getCollection(application);
+  const query = { uid };
+  if (userId) query.userId = userId;
+
+  return collection.findOne(query);
+}
+
+/**
+ * Get channel by MongoDB ObjectId
+ * @param {object} application - Indiekit application
+ * @param {ObjectId|string} id - Channel ObjectId
+ * @returns {Promise<object|null>} Channel or null
+ */
+export async function getChannelById(application, id) {
+  const collection = getCollection(application);
+  const objectId = typeof id === "string" ? new ObjectId(id) : id;
+  return collection.findOne({ _id: objectId });
+}
+
+/**
+ * Update a channel
+ * @param {object} application - Indiekit application
+ * @param {string} uid - Channel UID
+ * @param {object} updates - Fields to update
+ * @param {string} [userId] - User ID
+ * @returns {Promise<object|null>} Updated channel
+ */
+export async function updateChannel(application, uid, updates, userId) {
+  const collection = getCollection(application);
+  const query = { uid };
+  if (userId) query.userId = userId;
+
+  const result = await collection.findOneAndUpdate(
+    query,
+    {
+      $set: {
+        ...updates,
+        updatedAt: new Date(),
+      },
+    },
+    { returnDocument: "after" },
+  );
+
+  return result;
+}
+
+/**
+ * Delete a channel
+ * @param {object} application - Indiekit application
+ * @param {string} uid - Channel UID
+ * @param {string} [userId] - User ID
+ * @returns {Promise<boolean>} True if deleted
+ */
+export async function deleteChannel(application, uid, userId) {
+  const collection = getCollection(application);
+  const query = { uid };
+  if (userId) query.userId = userId;
+
+  // Don't allow deleting notifications channel
+  if (uid === "notifications") {
+    return false;
+  }
+
+  const result = await collection.deleteOne(query);
+  return result.deletedCount > 0;
+}
+
+/**
+ * Reorder channels
+ * @param {object} application - Indiekit application
+ * @param {Array} channelUids - Ordered array of channel UIDs
+ * @param {string} [userId] - User ID
+ * @returns {Promise<void>}
+ */
+export async function reorderChannels(application, channelUids, userId) {
+  const collection = getCollection(application);
+
+  // Update order for each channel
+  const operations = channelUids.map((uid, index) => ({
+    updateOne: {
+      filter: userId ? { uid, userId } : { uid },
+      update: { $set: { order: index, updatedAt: new Date() } },
+    },
+  }));
+
+  if (operations.length > 0) {
+    await collection.bulkWrite(operations);
+  }
+}
+
+/**
+ * Update channel settings
+ * @param {object} application - Indiekit application
+ * @param {string} uid - Channel UID
+ * @param {object} settings - Settings to update
+ * @param {Array} [settings.excludeTypes] - Types to exclude
+ * @param {string} [settings.excludeRegex] - Regex pattern to exclude
+ * @param {string} [userId] - User ID
+ * @returns {Promise<object|null>} Updated channel
+ */
+export async function updateChannelSettings(
+  application,
+  uid,
+  settings,
+  userId,
+) {
+  return updateChannel(application, uid, { settings }, userId);
+}
+
+/**
+ * Ensure notifications channel exists
+ * @param {object} application - Indiekit application
+ * @param {string} [userId] - User ID
+ * @returns {Promise<object>} Notifications channel
+ */
+export async function ensureNotificationsChannel(application, userId) {
+  const collection = getCollection(application);
+
+  const existing = await collection.findOne({
+    uid: "notifications",
+    ...(userId && { userId }),
+  });
+
+  if (existing) {
+    return existing;
+  }
+
+  // Create notifications channel
+  const channel = {
+    uid: "notifications",
+    name: "Notifications",
+    userId,
+    order: -1, // Always first
+    settings: {
+      excludeTypes: [],
+      excludeRegex: undefined,
+    },
+    createdAt: new Date(),
+    updatedAt: new Date(),
+  };
+
+  await collection.insertOne(channel);
+  return channel;
+}

package/lib/storage/feeds.js

@@ -0,0 +1,286 @@
+/**
+ * Feed subscription storage operations
+ * @module storage/feeds
+ */
+
+import { ObjectId } from "mongodb";
+
+/**
+ * Get feeds collection from application
+ * @param {object} application - Indiekit application
+ * @returns {object} MongoDB collection
+ */
+function getCollection(application) {
+  return application.collections.get("microsub_feeds");
+}
+
+/**
+ * Create a new feed subscription
+ * @param {object} application - Indiekit application
+ * @param {object} data - Feed data
+ * @param {ObjectId} data.channelId - Channel ObjectId
+ * @param {string} data.url - Feed URL
+ * @param {string} [data.title] - Feed title
+ * @param {string} [data.photo] - Feed icon URL
+ * @returns {Promise<object>} Created feed
+ */
+export async function createFeed(
+  application,
+  { channelId, url, title, photo },
+) {
+  const collection = getCollection(application);
+
+  // Check if feed already exists in channel
+  const existing = await collection.findOne({ channelId, url });
+  if (existing) {
+    return existing;
+  }
+
+  const feed = {
+    channelId,
+    url,
+    title: title || undefined,
+    photo: photo || undefined,
+    tier: 1, // Start at tier 1 (2 minutes)
+    unmodified: 0,
+    nextFetchAt: new Date(), // Fetch immediately
+    lastFetchedAt: undefined,
+    websub: undefined, // Will be populated if hub is discovered
+    createdAt: new Date(),
+    updatedAt: new Date(),
+  };
+
+  await collection.insertOne(feed);
+  return feed;
+}
+
+/**
+ * Get all feeds for a channel
+ * @param {object} application - Indiekit application
+ * @param {ObjectId|string} channelId - Channel ObjectId
+ * @returns {Promise<Array>} Array of feeds
+ */
+export async function getFeedsForChannel(application, channelId) {
+  const collection = getCollection(application);
+  const objectId =
+    typeof channelId === "string" ? new ObjectId(channelId) : channelId;
+
+  return collection.find({ channelId: objectId }).toArray();
+}
+
+/**
+ * Get a feed by URL and channel
+ * @param {object} application - Indiekit application
+ * @param {ObjectId|string} channelId - Channel ObjectId
+ * @param {string} url - Feed URL
+ * @returns {Promise<object|null>} Feed or null
+ */
+export async function getFeedByUrl(application, channelId, url) {
+  const collection = getCollection(application);
+  const objectId =
+    typeof channelId === "string" ? new ObjectId(channelId) : channelId;
+
+  return collection.findOne({ channelId: objectId, url });
+}
+
+/**
+ * Get a feed by ID
+ * @param {object} application - Indiekit application
+ * @param {ObjectId|string} id - Feed ObjectId
+ * @returns {Promise<object|null>} Feed or null
+ */
+export async function getFeedById(application, id) {
+  const collection = getCollection(application);
+  const objectId = typeof id === "string" ? new ObjectId(id) : id;
+
+  return collection.findOne({ _id: objectId });
+}
+
+/**
+ * Update a feed
+ * @param {object} application - Indiekit application
+ * @param {ObjectId|string} id - Feed ObjectId
+ * @param {object} updates - Fields to update
+ * @returns {Promise<object|null>} Updated feed
+ */
+export async function updateFeed(application, id, updates) {
+  const collection = getCollection(application);
+  const objectId = typeof id === "string" ? new ObjectId(id) : id;
+
+  const result = await collection.findOneAndUpdate(
+    { _id: objectId },
+    {
+      $set: {
+        ...updates,
+        updatedAt: new Date(),
+      },
+    },
+    { returnDocument: "after" },
+  );
+
+  return result;
+}
+
+/**
+ * Delete a feed subscription
+ * @param {object} application - Indiekit application
+ * @param {ObjectId|string} channelId - Channel ObjectId
+ * @param {string} url - Feed URL
+ * @returns {Promise<boolean>} True if deleted
+ */
+export async function deleteFeed(application, channelId, url) {
+  const collection = getCollection(application);
+  const objectId =
+    typeof channelId === "string" ? new ObjectId(channelId) : channelId;
+
+  const result = await collection.deleteOne({ channelId: objectId, url });
+  return result.deletedCount > 0;
+}
+
+/**
+ * Delete all feeds for a channel
+ * @param {object} application - Indiekit application
+ * @param {ObjectId|string} channelId - Channel ObjectId
+ * @returns {Promise<number>} Number of deleted feeds
+ */
+export async function deleteFeedsForChannel(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;
+}
+
+/**
+ * Get feeds ready for polling
+ * @param {object} application - Indiekit application
+ * @returns {Promise<Array>} Array of feeds to fetch
+ */
+export async function getFeedsToFetch(application) {
+  const collection = getCollection(application);
+  const now = new Date();
+
+  return collection
+    .find({
+      $or: [{ nextFetchAt: undefined }, { nextFetchAt: { $lte: now } }],
+    })
+    .toArray();
+}
+
+/**
+ * Update feed after fetch
+ * @param {object} application - Indiekit application
+ * @param {ObjectId|string} id - Feed ObjectId
+ * @param {boolean} changed - Whether content changed
+ * @param {object} [extra] - Additional fields to update
+ * @returns {Promise<object|null>} Updated feed
+ */
+export async function updateFeedAfterFetch(
+  application,
+  id,
+  changed,
+  extra = {},
+) {
+  const collection = getCollection(application);
+  const objectId = typeof id === "string" ? new ObjectId(id) : id;
+
+  // If extra contains tier info, use that (from processor)
+  // Otherwise calculate locally (legacy behavior)
+  let updateData;
+
+  if (extra.tier === undefined) {
+    // Get current feed state for legacy calculation
+    const feed = await collection.findOne({ _id: objectId });
+    if (!feed) return;
+
+    let tier = feed.tier;
+    let unmodified = feed.unmodified;
+
+    if (changed) {
+      tier = Math.max(0, tier - 1);
+      unmodified = 0;
+    } else {
+      unmodified++;
+      if (unmodified >= 2) {
+        tier = Math.min(10, tier + 1);
+        unmodified = 0;
+      }
+    }
+
+    const minutes = Math.ceil(Math.pow(2, tier));
+    const nextFetchAt = new Date(Date.now() + minutes * 60 * 1000);
+
+    updateData = {
+      tier,
+      unmodified,
+      nextFetchAt,
+      lastFetchedAt: new Date(),
+      updatedAt: new Date(),
+    };
+  } else {
+    updateData = {
+      ...extra,
+      lastFetchedAt: new Date(),
+      updatedAt: new Date(),
+    };
+  }
+
+  return collection.findOneAndUpdate(
+    { _id: objectId },
+    { $set: updateData },
+    { returnDocument: "after" },
+  );
+}
+
+/**
+ * Update feed WebSub subscription
+ * @param {object} application - Indiekit application
+ * @param {ObjectId|string} id - Feed ObjectId
+ * @param {object} websub - WebSub data
+ * @param {string} websub.hub - Hub URL
+ * @param {string} [websub.topic] - Feed topic URL
+ * @param {string} [websub.secret] - Subscription secret
+ * @param {number} [websub.leaseSeconds] - Lease duration
+ * @returns {Promise<object|null>} Updated feed
+ */
+export async function updateFeedWebsub(application, id, websub) {
+  const collection = getCollection(application);
+  const objectId = typeof id === "string" ? new ObjectId(id) : id;
+
+  const websubData = {
+    hub: websub.hub,
+    topic: websub.topic,
+  };
+
+  // Only set these if provided (subscription confirmed)
+  if (websub.secret) {
+    websubData.secret = websub.secret;
+  }
+  if (websub.leaseSeconds) {
+    websubData.leaseSeconds = websub.leaseSeconds;
+    websubData.expiresAt = new Date(Date.now() + websub.leaseSeconds * 1000);
+  }
+
+  return collection.findOneAndUpdate(
+    { _id: objectId },
+    {
+      $set: {
+        websub: websubData,
+        updatedAt: new Date(),
+      },
+    },
+    { returnDocument: "after" },
+  );
+}
+
+/**
+ * Get feed by WebSub subscription ID
+ * Used for WebSub callback handling
+ * @param {object} application - Indiekit application
+ * @param {string} subscriptionId - Subscription ID (feed ObjectId as string)
+ * @returns {Promise<object|null>} Feed or null
+ */
+export async function getFeedBySubscriptionId(application, subscriptionId) {
+  return getFeedById(application, subscriptionId);
+}