Skip to content

Self-hosted, Self-Improving, Federated Everything App — dev management, agent orchestration, persistent mind, digital twin, second brain, and creative pipeline from a single dashboard over Tailscale to port the user into the OS

3.9 KB
Raw Blame
/**
 * RSS/Atom Feed Routes
 *
 * REST API for managing feed subscriptions and reading items:
 *   GET    /api/feeds              — list subscribed feeds
 *   POST   /api/feeds              — add a feed subscription
 *   DELETE /api/feeds/:id          — remove a feed
 *   POST   /api/feeds/:id/refresh  — refresh a single feed
 *   POST   /api/feeds/refresh-all  — refresh all feeds
 *   GET    /api/feeds/items        — get feed items (query: feedId, unreadOnly)
 *   GET    /api/feeds/stats        — get feed statistics
 *   POST   /api/feeds/items/:id/read     — mark item as read
 *   POST   /api/feeds/items/read-all     — mark all items as read (query: feedId)
 */

import { Router } from 'express';
import { z } from 'zod';
import { asyncHandler, ServerError } from '../lib/errorHandler.js';
import { validateRequest, parsePagination } from '../lib/validation.js';
import * as feedsService from '../services/feeds.js';

const router = Router();

const addFeedSchema = z.object({
  url: z.string().url()
});

const feedIdQuery = { feedId: z.string().min(1).max(200).optional() };
const itemsQuerySchema = z.object({
  ...feedIdQuery,
  unreadOnly: z.enum(['true', 'false']).optional(),
  // parsePagination clamps these; the schema only refuses non-scalar values.
  limit: z.string().max(20).optional(),
  offset: z.string().max(20).optional(),
});
const readAllQuerySchema = z.object(feedIdQuery);

// GET /api/feeds — list all feeds with unread counts
router.get('/', asyncHandler(async (req, res) => {
  const feeds = await feedsService.getFeeds();
  res.json(feeds);
}));

// GET /api/feeds/stats — feed statistics
router.get('/stats', asyncHandler(async (req, res) => {
  const stats = await feedsService.getFeedStats();
  res.json(stats);
}));

// GET /api/feeds/items — get feed items (supports limit/offset pagination, default limit 100)
router.get('/items', asyncHandler(async (req, res) => {
  const query = validateRequest(itemsQuerySchema, req.query);
  const { feedId, unreadOnly } = query;
  const { limit, offset } = parsePagination(query, { defaultLimit: 100, maxLimit: 500 });
  const items = await feedsService.getItems({
    feedId: feedId || undefined,
    unreadOnly: unreadOnly === 'true',
    limit,
    offset
  });
  res.json(items);
}));

// POST /api/feeds — add a new feed subscription
router.post('/', asyncHandler(async (req, res) => {
  const { url } = validateRequest(addFeedSchema, req.body);
  const result = await feedsService.addFeed(url);
  if (result.error) {
    throw new ServerError(result.error, { status: 400 });
  }
  res.status(201).json(result.feed);
}));

// POST /api/feeds/refresh-all — refresh all feeds
router.post('/refresh-all', asyncHandler(async (req, res) => {
  const result = await feedsService.refreshAllFeeds();
  res.json(result);
}));

// POST /api/feeds/items/read-all — mark all items as read
router.post('/items/read-all', asyncHandler(async (req, res) => {
  const { feedId } = validateRequest(readAllQuerySchema, req.query);
  const result = await feedsService.markAllRead(feedId || undefined);
  res.json(result);
}));

// POST /api/feeds/items/:id/read — mark single item as read
router.post('/items/:id/read', asyncHandler(async (req, res) => {
  const result = await feedsService.markItemRead(req.params.id);
  if (result.error) {
    throw new ServerError(result.error, { status: 404 });
  }
  res.json(result);
}));

// POST /api/feeds/:id/refresh — refresh a single feed
router.post('/:id/refresh', asyncHandler(async (req, res) => {
  const result = await feedsService.refreshFeed(req.params.id);
  if (result.error) {
    throw new ServerError(result.error, { status: 404 });
  }
  res.json(result);
}));

// DELETE /api/feeds/:id — remove a feed subscription
router.delete('/:id', asyncHandler(async (req, res) => {
  const result = await feedsService.removeFeed(req.params.id);
  if (result.error) {
    throw new ServerError(result.error, { status: 404 });
  }
  res.json(result);
}));

export default router;