@sdxc/messaging

import type { Message } from "@sdxc/messaging";

import { SlackWebhook } from "@sdxc/messaging/slack";
import { isFailure } from "@sdxc/result";

let message: Message = {
	title: "api.example.com is down",
	text: "The check from **São Paulo** timed out after `30s`.",
	severity: "critical",
	fields: [{ label: "Region", value: "gru", inline: true }],
	links: [{ label: "Open dashboard", url: "https://status.example.com/monitors/1" }],
	timestamp: new Date(),
};

let sent = await new SlackWebhook({ url: webhookUrl }).send(message, { timeout: "10 seconds" });
if (isFailure(sent)) console.error(sent.error.code, sent.error.retryable);

import type { Destination } from "@sdxc/messaging";

import { DiscordWebhook } from "@sdxc/messaging/discord";
import { PagerDuty } from "@sdxc/messaging/pagerduty";
import { SlackWebhook } from "@sdxc/messaging/slack";
import { TelegramBot } from "@sdxc/messaging/telegram";
import { env } from "cloudflare:workers";

type Channel =
	| { kind: "slack" | "discord"; url: string }
	| { kind: "pagerduty"; routingKey: string }
	| { kind: "telegram"; chatId: string };

function destinationFor(channel: Channel): Destination {
	switch (channel.kind) {
		case "slack":
			return new SlackWebhook({ url: channel.url });
		case "discord":
			return new DiscordWebhook({ url: channel.url });
		case "pagerduty":
			return new PagerDuty({ routingKey: channel.routingKey });
		case "telegram":
			return new TelegramBot({ token: () => env.TELEGRAM_BOT_TOKEN, chatId: channel.chatId });
	}
}

import { SlackWebhook } from "@sdxc/messaging/slack";
import { isFailure } from "@sdxc/result";

let checked = SlackWebhook.check(String(form.get("url")));
if (isFailure(checked)) return { error: "Paste a Slack incoming webhook URL" };

import { supports } from "@sdxc/messaging";
import { isSuccess } from "@sdxc/result";

let sent = await destination.send(downMessage);
if (isSuccess(sent) && sent.data.ref) await saveRef(incidentId, sent.data.ref);

let ref = await loadRef(incidentId);
if (ref && supports(destination, "update")) await destination.update(ref, recoveredMessage);
else if (ref && supports(destination, "reply")) await destination.reply(ref, recoveredMessage);
else await destination.send(recoveredMessage);

import type { Destination, Message } from "@sdxc/messaging";

import { isSuccess } from "@sdxc/result";

/** Reads the stored channel and builds its provider, as `destinationFor` above does. */
declare function loadDestination(channelId: string): Promise<Destination>;
declare function markChannelBroken(id: string): Promise<void>;

const MAX_ATTEMPTS = 6;

async function deliver(
	input: { channelId: string; deliveryId: string; message: Message },
	attempt: number,
) {
	let destination = await loadDestination(input.channelId);
	let sent = await destination.send(input.message, { id: input.deliveryId });
	if (isSuccess(sent)) return { done: true };

	let error = sent.error;
	if (error.retryable && attempt < MAX_ATTEMPTS) {
		return { retryIn: error.retryAfter ?? 30_000 * 2 ** attempt };
	}
	if (error.code === "gone") await markChannelBroken(input.channelId);
	return { done: true, failed: error.code };
}

import { MESSAGE_SCHEMA } from "@sdxc/messaging";
import * as s from "remix/data-schema";

let DeliverInput = s.object({
	channelId: s.string(),
	deliveryId: s.string(),
	message: MESSAGE_SCHEMA,
});

import type { Message } from "@sdxc/messaging";

import { Opsgenie } from "@sdxc/messaging/opsgenie";
import { PagerDuty } from "@sdxc/messaging/pagerduty";
import { env } from "cloudflare:workers";

let destinations = [
	new PagerDuty({ routingKey: () => env.PAGERDUTY_ROUTING_KEY, source: "checkout-api" }),
	new Opsgenie({ apiKey: () => env.OPSGENIE_API_KEY, region: "eu", tags: ["checkout"] }),
];

let down: Message = {
	title: "Checkout is failing",
	severity: "critical",
	key: "checkout",
	data: { errorRate: 0.42 },
};
let recovered: Message = { title: "Checkout recovered", key: "checkout", state: "resolved" };

for (let destination of destinations) await destination.send(down);
for (let destination of destinations) await destination.send(recovered);

import { BrowserPush } from "@sdxc/messaging/web-push";
import { isFailure } from "@sdxc/result";
import { WebPush } from "@sdxc/web-push";
import { env } from "cloudflare:workers";

let push = new WebPush({
	vapid: {
		publicKey: env.VAPID_PUBLIC_KEY,
		privateKey: env.VAPID_PRIVATE_KEY,
		subject: "mailto:ops@example.com",
	},
});

for (let subscription of subscriptions) {
	let sent = await new BrowserPush({ push, subscription, ttl: "1 day" }).send(message);
	if (isFailure(sent) && sent.error.code === "gone") await deleteSubscription(subscription);
}

declare let self: ServiceWorkerGlobalScope;

self.addEventListener("push", (event) => {
	let payload = event.data?.json();
	event.waitUntil(
		self.registration.showNotification(payload.title, {
			body: payload.body,
			tag: payload.tag,
			data: { url: payload.url },
		}),
	);
});

self.addEventListener("notificationclick", (event) => {
	event.notification.close();
	let url = event.notification.data?.url;
	if (url) event.waitUntil(self.clients.openWindow(url));
});

import { WhatsAppCloud } from "@sdxc/messaging/whatsapp";
import { env } from "cloudflare:workers";

let whatsapp = new WhatsAppCloud({
	accessToken: () => env.WHATSAPP_ACCESS_TOKEN,
	phoneNumberId: env.WHATSAPP_PHONE_NUMBER_ID,
	to: "+5511999990000",
	template: {
		name: "incident_alert",
		language: "en",
		parameters: (message) => [message.title, message.fields?.[0]?.value ?? "unknown"],
	},
});

let sent = await whatsapp.send(message);

import type { Message } from "@sdxc/messaging";

import { fitText, telegramHtml, writeText } from "@sdxc/messaging";
import { SlackWebhook } from "@sdxc/messaging/slack";
import { TelegramBot } from "@sdxc/messaging/telegram";

class CompactSlack extends SlackWebhook {
	override render(message: Message) {
		let payload = super.render(message);
		payload.attachments[0].blocks = payload.attachments[0].blocks.filter(
			(block) => block.type !== "context",
		);
		return payload;
	}
}

class TerseTelegram extends TelegramBot {
	override render(message: Message) {
		let payload = super.render(message);
		let title = telegramHtml.strong(fitText(message.title, 120, telegramHtml.escape));
		let text = message.text ? writeText(message.text, telegramHtml, 1_000) : "";
		payload.text = text === "" ? title : `${title}\n\n${text}`;
		return payload;
	}
}

import type { Message } from "@sdxc/messaging";
import type { WebhookDelivery, WebhookSignContext } from "@sdxc/messaging/webhook";

import { webhookEnvelope, Webhook } from "@sdxc/messaging/webhook";
import { success } from "@sdxc/result";

class HmacWebhook extends Webhook {
	override render(message: Message, delivery: WebhookDelivery) {
		return { event: "alert", id: delivery.id, ...webhookEnvelope(message) };
	}

	protected override async sign(body: string, context: WebhookSignContext) {
		let encoder = new TextEncoder();
		let key = await crypto.subtle.importKey(
			"raw",
			encoder.encode(context.secret),
			{ name: "HMAC", hash: "SHA-256" },
			false,
			["sign"],
		);
		let mac = new Uint8Array(await crypto.subtle.sign("HMAC", key, encoder.encode(body)));
		let hex = Array.from(mac, (byte) => byte.toString(16).padStart(2, "0")).join("");
		return success(new Headers({ "X-Signature": `sha256=${hex}` }));
	}
}

await new HmacWebhook({ url: endpoint, secret: () => env.WEBHOOK_SECRET }).send(message, {
	id: deliveryId,
});

import { describeDestination } from "@sdxc/messaging/conformance";
import { MemoryDestination } from "@sdxc/messaging/memory";
import { isFailure } from "@sdxc/result";
import { expect, test } from "vitest";

test("sends the alert once the platform recovers", async () => {
	let destination = new MemoryDestination();
	destination.failNext({ code: "rate-limited", retryAfter: 30_000 });

	let first = await destination.send(message);
	expect(isFailure(first) && first.error.retryAfter).toBe(30_000);

	await destination.send(message);
	expect(destination.messages).toHaveLength(1);
	expect(destination.last?.message.title).toBe(message.title);
});

let current: MemoryDestination;

describeDestination({
	name: "memory",
	create: () => (current = new MemoryDestination({ capabilities: ["update", "reply"] })),
	capabilities: ["update", "reply"],
	rateLimitNext: (delayMs) => current.failNext({ code: "rate-limited", retryAfter: delayMs }),
});