Publish RSS, Atom and JSON feeds

import { toHTML } from "@sdxc/markdown/html";
import { isFailure } from "@sdxc/result";

import { listPosts } from "~/app/content/list-posts";
import { readPost } from "~/app/content/posts";
import routes from "~/routes/web";

export interface FeedEntry {
	url: string;
	title: string;
	summary: string;
	html: string;
	publishedAt: Date;
	tags: string[];
}

export async function feedEntries(origin: string, limit = 20): Promise<FeedEntry[]> {
	let entries: FeedEntry[] = [];

	for (let post of (await listPosts()).slice(0, limit)) {
		let read = await readPost(post.slug);
		if (read === null || isFailure(read)) continue;

		let url = new URL(routes.posts.show.href({ slug: post.slug }), origin).href;
		let html = toHTML(read.data.document);
		let { title, description: summary, publishedAt, tags } = post;
		entries.push({ url, title, summary, html, publishedAt, tags });
	}

	return entries;
}

import { get, route } from "remix/routes";

export default route({
	posts: { index: get("/posts"), show: get("/posts/:slug") },
	feeds: {
		rss: get("/feed.xml"),
		atom: get("/atom.xml"),
		json: get("/feed.json"),
		opml: get("/feeds.opml"),
	},
});

import { xml } from "@sdxc/http/response";
import { RSS } from "@sdxc/rss";
import { createAction } from "remix/router";

import { feedEntries } from "~/app/feeds/entries";
import routes from "~/routes/web";

export default createAction(routes.feeds.rss, async (ctx) => {
	let self = new URL(routes.feeds.rss.href(), ctx.url).href;
	let entries = await feedEntries(ctx.url.origin);

	let rss = new RSS({
		title: "Example",
		description: "Notes on building for the web.",
		link: ctx.url.origin,
		language: "en",
		lastBuildDate: entries[0]?.publishedAt.toUTCString(),
		atomLink: { rel: "self", href: self, type: "application/rss+xml" },
	});

	for (let entry of entries) {
		rss.addItem({
			guid: { value: entry.url, isPermaLink: true },
			title: entry.title,
			description: entry.summary,
			link: entry.url,
			category: entry.tags,
			pubDate: entry.publishedAt.toUTCString(),
			contentEncoded: entry.html,
		});
	}

	return xml(rss.toString());
});

import { Atom } from "@sdxc/atom";
import { xml } from "@sdxc/http/response";
import { createAction } from "remix/router";

import { feedEntries } from "~/app/feeds/entries";
import routes from "~/routes/web";

export default createAction(routes.feeds.atom, async (ctx) => {
	let self = new URL(routes.feeds.atom.href(), ctx.url).href;
	let entries = await feedEntries(ctx.url.origin);

	let atom = new Atom({
		id: self,
		title: "Example",
		updated: (entries[0]?.publishedAt ?? new Date()).toISOString(),
		author: { name: "Ada Lovelace", uri: ctx.url.origin },
		link: [
			{ href: ctx.url.origin, rel: "alternate", type: "text/html" },
			{ href: self, rel: "self", type: "application/atom+xml" },
		],
	});

	for (let entry of entries) {
		atom.addEntry({
			id: entry.url,
			title: entry.title,
			updated: entry.publishedAt.toISOString(),
			published: entry.publishedAt.toISOString(),
			summary: entry.summary,
			content: { type: "html", value: entry.html },
			link: { href: entry.url, rel: "alternate" },
			category: entry.tags,
		});
	}

	return xml(atom.toString());
});

import { JSONFeed } from "@sdxc/json-feed";
import { createAction } from "remix/router";

import { feedEntries } from "~/app/feeds/entries";
import routes from "~/routes/web";

export default createAction(routes.feeds.json, async (ctx) => {
	let feed = new JSONFeed({
		title: "Example",
		homePageUrl: ctx.url.origin,
		feedUrl: new URL(routes.feeds.json.href(), ctx.url).href,
		language: "en",
		authors: [{ name: "Ada Lovelace", url: ctx.url.origin }],
	});

	for (let entry of await feedEntries(ctx.url.origin)) {
		feed.addItem({
			id: entry.url,
			url: entry.url,
			title: entry.title,
			summary: entry.summary,
			contentHtml: entry.html,
			datePublished: entry.publishedAt.toISOString(),
			tags: entry.tags,
		});
	}

	return new Response(feed.toString(), {
		headers: { "content-type": JSONFeed.mediaType },
	});
});

import routes from "~/routes/web";

export function FeedLinks() {
	return () => (
		<>
			<link
				rel="alternate"
				type="application/rss+xml"
				title="Example"
				href={routes.feeds.rss.href()}
			/>
			<link
				rel="alternate"
				type="application/atom+xml"
				title="Example (Atom)"
				href={routes.feeds.atom.href()}
			/>
			<link
				rel="alternate"
				type="application/feed+json"
				title="Example (JSON Feed)"
				href={routes.feeds.json.href()}
			/>
		</>
	);
}

import { links } from "@sdxc/websub/publisher";
import { env } from "cloudflare:workers";

export function advertiseHub(self: string, type: string) {
	return {
		links: [
			{ rel: "self", href: self, type },
			{ rel: "hub", href: env.WEBSUB_HUB },
		],
		headers: { link: links({ hubs: [env.WEBSUB_HUB], self }) },
	};
}

import { job, jobs } from "@sdxc/jobs";
import * as s from "remix/data-schema";

export default jobs({
	feeds: {
		ping: job({ input: s.object({ topics: s.array(s.string()) }) }),
	},
});

import { createJobHandler } from "@sdxc/jobs";
import { isFailure } from "@sdxc/result";
import { publish } from "@sdxc/websub/publisher";
import { env } from "cloudflare:workers";

import jobs from "~/app/jobs";

export default createJobHandler(jobs.feeds.ping, async (ctx) => {
	let pinged = await publish(env.WEBSUB_HUB, ctx.input.topics);
	if (!isFailure(pinged)) return;

	let { status } = pinged.error;
	ctx.log.set({ websub: { status, topics: ctx.input.topics.length } });

	if (status === null || status >= 500 || status === 429) {
		return ctx.retry({ delay: "5 minutes", cause: pinged.error });
	}
	return ctx.ack(pinged.error.message);
});

import routes from "~/routes/web";

export function feedTopics(base: URL): string[] {
	let feeds = [routes.feeds.rss, routes.feeds.atom, routes.feeds.json];
	return feeds.map((feed) => new URL(feed.href(), base).href);
}

import type { OPML } from "@sdxc/opml";

import { xml } from "@sdxc/http/response";
import { stringify } from "@sdxc/opml";
import { createAction } from "remix/router";

import routes from "~/routes/web";

const BLOGROLL: OPML.Outline[] = [
	{
		title: "Friend",
		feedUrl: "https://friend.example/feed.xml",
		folder: "Friends",
	},
];

export default createAction(routes.feeds.opml, (ctx) => {
	let feedUrl = new URL(routes.feeds.rss.href(), ctx.url).href;
	let outlines = [
		{ title: "Example", feedUrl, siteUrl: ctx.url.origin },
		...BLOGROLL,
	];

	let title = "Example and friends";
	return xml(stringify(outlines, { title, dateCreated: new Date() }));
});