Run a newsletter list

import type { Newsletter } from "@sdxc/newsletter";

import { ButtondownNewsletter } from "@sdxc/newsletter/buttondown";
import { env } from "cloudflare:workers";

export const buttondown: Newsletter = new ButtondownNewsletter({
	apiKey: env.BUTTONDOWN_API_KEY,
	webhookSecret: env.BUTTONDOWN_WEBHOOK_SECRET,
	confirmation: "double",
});

import type { Newsletter } from "@sdxc/newsletter";

import { KitNewsletter } from "@sdxc/newsletter/kit";
import { env } from "cloudflare:workers";

export const kit: Newsletter = new KitNewsletter({
	apiKey: env.KIT_API_KEY,
	webhookSecret: env.KIT_WEBHOOK_SECRET,
	form: { id: "55", confirmation: "double" },
});

import type { Newsletter } from "@sdxc/newsletter";
import type { Middleware } from "remix/router";

import { attribution } from "@sdxc/attribution/middleware";
import getClientIP from "@sdxc/get-client-ip/middleware";
import { log } from "@sdxc/logger/middleware";
import newsletter from "@sdxc/newsletter/middleware";
import { formData } from "remix/middleware/form-data";
import { createRouter } from "remix/router";

import * as subscribe from "~/app/http/controllers/subscribe";
import { attributionCookie } from "~/app/lib/cookies";
import { buttondown } from "~/app/lib/newsletter";
import { createNewsletterWebhook } from "~/app/lib/newsletter-webhook";
import routes from "~/routes/web";

import { logger } from "./logger";

export default function application(list: Newsletter = buttondown) {
	let middleware: Middleware[] = [
		log(logger) as Middleware,
		getClientIP(),
		attribution({ store: attributionCookie() }),
		formData() as Middleware,
		newsletter({ provider: list }),
		// …then cop() and a renderer
	];

	let router = createRouter({ middleware });
	router.map(routes.subscribe, {
		actions: { index: subscribe.index, action: subscribe.action },
	});
	router.map(routes.webhooks.newsletter, createNewsletterWebhook(list));
	return router;
}

import type { RequestContext } from "remix/router";

import { createAction } from "remix/router";

import { SubscribePage } from "~/resources/views/subscribe";
import routes from "~/routes/web";

export function renderSubscribe(ctx: RequestContext, error?: string) {
	return ctx.render(
		<SubscribePage error={error}>
			<form method="post" action={routes.subscribe.action.href()}>
				<input name="email" type="email" autocomplete="email" required />
				<button type="submit">Subscribe</button>
			</form>
		</SubscribePage>,
		{ status: error ? 400 : 200 },
	);
}

export const index = createAction(routes.subscribe.index, (ctx) =>
	renderSubscribe(ctx),
);

import { toCampaign } from "@sdxc/attribution";
import { parseEmailAddress } from "@sdxc/email-address";
import { redirect } from "@sdxc/http/response";
import { isFailure } from "@sdxc/result";
import { validate } from "@sdxc/validate";
import * as s from "remix/data-schema";

const SUBSCRIBE = s.object({ email: s.string() });

export const action = createAction(routes.subscribe.action, async (ctx) => {
	let form = await validate(ctx.formData, SUBSCRIBE);
	if (isFailure(form)) return renderSubscribe(ctx, "Enter your email address.");

	let email = parseEmailAddress(form.data.email);
	if (isFailure(email))
		return renderSubscribe(ctx, "That is not an email address.");

	let touch = ctx.attribution.last ?? ctx.attribution.first;
	let outcome = await ctx.newsletter.subscribers.subscribe({
		email: email.data,
		tags: ["blog"],
		attribution: toCampaign(touch, ctx.url),
		ip: ctx.ip,
	});

	if (isFailure(outcome)) {
		let code = outcome.error.code;
		if (code === "invalid_address") {
			return renderSubscribe(ctx, "That address cannot receive email.");
		}
		if (code === "suppressed") {
			return renderSubscribe(ctx, "That address cannot be subscribed.");
		}
		ctx.log.fail(outcome.error);
		return renderSubscribe(ctx, "Something went wrong. Please try again.");
	}

	ctx.log.set({ newsletter: { created: outcome.data.created } });
	return redirect(routes.checkYourEmail.href(), {
		status: redirect.Status.SeeOther,
	});
});

import type { EmailAddress } from "@sdxc/email-address";
import type { Newsletter, NewsletterError } from "@sdxc/newsletter";
import type { Result } from "@sdxc/result";

import { failure, isFailure, success } from "@sdxc/result";

export async function tagCustomer(
	newsletter: Newsletter,
	email: EmailAddress,
	plan: string,
): Promise<Result<null, NewsletterError>> {
	let updated = await newsletter.subscribers.update(
		{ email },
		{ tags: { add: ["customer"] }, metadata: { plan, trial: null } },
	);

	if (isFailure(updated) && updated.error.code !== "not_found") {
		return failure(updated.error);
	}
	return success(null);
}

import type { Newsletter } from "@sdxc/newsletter";

import { NewsletterWebhook } from "@sdxc/newsletter";
import { KVReplayStore } from "@sdxc/webhooks";
import { env } from "cloudflare:workers";

import { setReaderStatus } from "~/app/data/readers";

export function createNewsletterWebhook(provider: Newsletter): NewsletterWebhook {
	return new NewsletterWebhook(
		provider,
		{
			async "subscriber.confirmed"(event, ctx) {
				await setReaderStatus(ctx.db, event.subscriberId, "active");
			},
			async "subscriber.unsubscribed"(event, ctx) {
				await setReaderStatus(ctx.db, event.subscriberId, "unsubscribed");
			},
			async "subscriber.suppressed"(event, ctx) {
				await setReaderStatus(ctx.db, event.subscriberId, "suppressed");
			},
		},
		{ store: new KVReplayStore(env.WEBHOOKS, { prefix: "newsletter:" }) },
	);
}

import { MemoryNewsletter } from "@sdxc/newsletter/memory";
import { unwrap } from "@sdxc/result";
import { expect, test } from "vitest";

import application from "~/bootstrap/app";

const ORIGIN = "https://example.com";

function post(list: MemoryNewsletter, email: string, cookie = "") {
	let request = new Request(`${ORIGIN}/subscribe`, {
		method: "POST",
		headers: { origin: ORIGIN, cookie },
		body: new URLSearchParams({ email }),
	});
	return application(list).fetch(request);
}

test("a new reader waits for confirmation", async () => {
	let list = new MemoryNewsletter();

	let response = await post(list, "reader@example.com");
	let page = await unwrap(list.subscribers.list());

	expect(response.status).toBe(303);
	expect(page.items.map((reader) => reader.status)).toEqual(["pending"]);
	expect(unwrap(list.confirm("reader@example.com")).status).toBe("active");
});

test("a suppressed address sees its own copy", async () => {
	let list = new MemoryNewsletter();
	list.fail("subscribers.subscribe", "suppressed");

	let response = await post(list, "reader@example.com");

	expect(await response.text()).toContain("cannot be subscribed");
});

test("credits the campaign the visitor landed from", async () => {
	let list = new MemoryNewsletter();
	let landing = await application(list).fetch(
		new Request(`${ORIGIN}/subscribe?utm_source=Mastodon&utm_campaign=Launch`, {
			headers: { "sec-fetch-dest": "document" },
		}),
	);
	let cookie = landing.headers.get("set-cookie")?.split(";")[0] ?? "";

	await post(list, "reader@example.com", cookie);

	expect(list.attribution("reader@example.com")).toMatchObject({
		source: "mastodon",
		campaign: "launch",
	});
});

import { MemoryNewsletter } from "@sdxc/newsletter/memory";
import { unwrap } from "@sdxc/result";
import { expect, test } from "vitest";

import application from "~/bootstrap/app";

test("refuses a delivery the configured secret does not prove", async () => {
	let sender = new MemoryNewsletter();
	let [reader] = sender.seed([{ email: "reader@example.com" }]);
	let delivery = unwrap(
		await sender.webhooks.emit({
			type: "subscriber.unsubscribed",
			subscriberId: reader?.id ?? "",
		}),
	);

	let unconfigured = new MemoryNewsletter({ webhookSecret: "" });
	let response = await application(unconfigured).fetch(delivery.request);

	expect(response.status).toBe(401);
});

import { conformance } from "@sdxc/newsletter/conformance";

import { MailingListNewsletter, signDelivery } from "~/app/lib/mailing-list";

const API_KEY = "test-key";
const SECRET = "test-webhook-secret";

conformance({
	name: "MailingListNewsletter",
	create: () =>
		new MailingListNewsletter({ apiKey: API_KEY, webhookSecret: SECRET }),
	createWithoutSecret: () => new MailingListNewsletter({ apiKey: API_KEY }),
	confirmation: "double",
	deliver: (_provider, subscriber) => signDelivery(SECRET, subscriber),
});