Open-source status page, incident response and uptime monitoring
TypeScript alertingincident-managementmcpmcp-servermonitoringmonitoring-as-codeobservabilityon-callopen-sourcesrestatus-pagestatuspagesynthetic-monitoringterraformtinybirdtursouptimeuptime-checkeruptime-monitor
import { Events } from "@openstatus/analytics";
import {
discordDataSchema,
googleChatDataSchema,
grafanaOncallDataSchema,
msTeamsDataSchema,
notificationProvider,
ntfyDataSchema,
opsgenieDataSchema,
pagerdutyDataSchema,
slackDataSchema,
telegramDataSchema,
webhookDataSchema,
whatsappDataSchema,
} from "@openstatus/db/src/schema";
import { SchemaError } from "@openstatus/error";
import { sendTest as sendWhatsAppTest } from "@openstatus/notification-bird-whatsapp";
import { sendTestDiscordMessage as sendDiscordTest } from "@openstatus/notification-discord";
import { sendTest as sendGoogleChatTest } from "@openstatus/notification-google-chat";
import { sendTest as sendGrafanaTest } from "@openstatus/notification-grafana-oncall";
import { sendTest as sendMsTeamsTest } from "@openstatus/notification-ms-teams";
import { sendTest as sendNtfyTest } from "@openstatus/notification-ntfy";
import { sendTest as sendOpsGenieTest } from "@openstatus/notification-opsgenie";
import {
PagerDutySchema,
sendTest as sendPagerDutyTest,
} from "@openstatus/notification-pagerduty";
import { sendTestSlackMessage as sendSlackTest } from "@openstatus/notification-slack";
import { sendTest as sendTelegramTest } from "@openstatus/notification-telegram";
import { sendTest as sendWebhookTest } from "@openstatus/notification-webhook";
import { NotFoundError } from "@openstatus/services";
import {
NotificationDataInputSchema,
createNotification,
deleteNotification,
listNotifications,
updateNotification,
} from "@openstatus/services/notification";
import { redis } from "@openstatus/upstash";
import { TRPCError } from "@trpc/server";
import { nanoid } from "nanoid";
import { z } from "zod";
import { toServiceCtx, toTRPCError } from "../service-adapter";
import {
type TelegramGetUpdatesResponse,
processTelegramUpdates,
} from "../service/telegram-updates";
import { createTRPCRouter, protectedProcedure } from "../trpc";
export const notificationRouter = createTRPCRouter({
list: protectedProcedure.query(async ({ ctx }) => {
try {
const { items } = await listNotifications({
ctx: toServiceCtx(ctx),
input: {
// Dashboard has no paging UI; match the sentinel pattern used
// across the other domains.
limit: 10_000,
offset: 0,
order: "desc",
},
});
return items;
} catch (err) {
toTRPCError(err);
}
}),
// TODO: rename to update after migration
updateNotifier: protectedProcedure
.meta({ track: Events.UpdateNotification })
.input(
z.object({
id: z.number(),
name: z.string(),
data: NotificationDataInputSchema,
monitors: z.array(z.number()),
}),
)
.mutation(async ({ ctx, input }) => {
try {
await updateNotification({
ctx: toServiceCtx(ctx),
input: {
id: input.id,
name: input.name,
data: input.data,
monitors: input.monitors,
},
});
} catch (err) {
toTRPCError(err);
}
}),
new: protectedProcedure
.meta({ track: Events.CreateNotification, trackProps: ["provider"] })
.input(
z.object({
provider: z.enum(notificationProvider),
data: NotificationDataInputSchema,
name: z.string(),
monitors: z.array(z.number()).prefault([]),
}),
)
.mutation(async ({ ctx, input }) => {
try {
return await createNotification({
ctx: toServiceCtx(ctx),
input: {
name: input.name,
provider: input.provider,
data: input.data,
monitors: input.monitors,
},
});
} catch (err) {
toTRPCError(err);
}
}),
delete: protectedProcedure
.meta({ track: Events.DeleteNotification })
.input(z.object({ id: z.number() }))
.mutation(async ({ ctx, input }) => {
try {
await deleteNotification({
ctx: toServiceCtx(ctx),
input: { id: input.id },
});
} catch (err) {
// Preserve the pre-migration idempotent behaviour — the old tRPC
// delete didn't throw on missing.
if (err instanceof NotFoundError) return;
toTRPCError(err);
}
}),
sendTest: protectedProcedure
.meta({ track: Events.TestNotification, trackProps: ["provider"] })
.input(
z.object({
provider: z.enum(notificationProvider),
data: NotificationDataInputSchema,
}),
)
.mutation(async (opts) => {
if (opts.input.provider === "telegram") {
const _data = telegramDataSchema.safeParse(opts.input.data);
if (!_data.success) {
throw new TRPCError({
code: "BAD_REQUEST",
message: SchemaError.fromZod(_data.error, opts.input).message,
});
}
await sendTelegramTest({
chatId: _data.data.telegram.chatId,
});
return;
}
if (opts.input.provider === "whatsapp") {
const _data = whatsappDataSchema.safeParse(opts.input.data);
if (!_data.success) {
throw new TRPCError({
code: "BAD_REQUEST",
message: SchemaError.fromZod(_data.error, opts.input).message,
});
}
await sendWhatsAppTest({ phoneNumber: _data.data.whatsapp });
return;
}
if (opts.input.provider === "google-chat") {
const _data = googleChatDataSchema.safeParse(opts.input.data);
if (!_data.success) {
throw new TRPCError({
code: "BAD_REQUEST",
message: SchemaError.fromZod(_data.error, opts.input).message,
});
}
await sendGoogleChatTest(_data.data["google-chat"]);
return;
}
if (opts.input.provider === "grafana-oncall") {
const _data = grafanaOncallDataSchema.safeParse(opts.input.data);
if (!_data.success) {
throw new TRPCError({
code: "BAD_REQUEST",
message: SchemaError.fromZod(_data.error, opts.input).message,
});
}
if (!(await sendGrafanaTest(_data.data["grafana-oncall"]))) {
throw new TRPCError({
code: "BAD_REQUEST",
message: "Failed to send test",
});
}
return;
}
if (opts.input.provider === "ms-teams") {
const _data = msTeamsDataSchema.safeParse(opts.input.data);
if (!_data.success) {
throw new TRPCError({
code: "BAD_REQUEST",
message: SchemaError.fromZod(_data.error, opts.input).message,
});
}
await sendMsTeamsTest({
webhookUrl: _data.data["ms-teams"].webhookUrl,
});
return;
}
if (opts.input.provider === "discord") {
const _data = discordDataSchema.safeParse(opts.input.data);
if (!_data.success) {
throw new TRPCError({
code: "BAD_REQUEST",
message: SchemaError.fromZod(_data.error, opts.input).message,
});
}
await sendDiscordTest(_data.data.discord);
return;
}
if (opts.input.provider === "slack") {
const _data = slackDataSchema.safeParse(opts.input.data);
if (!_data.success) {
throw new TRPCError({
code: "BAD_REQUEST",
message: SchemaError.fromZod(_data.error, opts.input).message,
});
}
await sendSlackTest(_data.data.slack);
return;
}
if (opts.input.provider === "webhook") {
const _data = webhookDataSchema.safeParse(opts.input.data);
if (!_data.success) {
throw new TRPCError({
code: "BAD_REQUEST",
message: SchemaError.fromZod(_data.error, opts.input).message,
});
}
await sendWebhookTest({
url: _data.data.webhook.endpoint,
headers: _data.data.webhook.headers,
});
return;
}
if (opts.input.provider === "opsgenie") {
const _data = opsgenieDataSchema.safeParse(opts.input.data);
if (!_data.success) {
throw new TRPCError({
code: "BAD_REQUEST",
message: SchemaError.fromZod(_data.error, opts.input).message,
});
}
await sendOpsGenieTest(_data.data.opsgenie);
return;
}
if (opts.input.provider === "ntfy") {
const _data = ntfyDataSchema.safeParse(opts.input.data);
if (!_data.success) {
throw new TRPCError({
code: "BAD_REQUEST",
message: SchemaError.fromZod(_data.error, opts.input).message,
});
}
if (!(await sendNtfyTest(_data.data.ntfy))) {
throw new TRPCError({
code: "BAD_REQUEST",
message: "Failed to send test",
});
}
return;
}
if (opts.input.provider === "pagerduty") {
const _data = pagerdutyDataSchema.safeParse(opts.input.data);
if (!_data.success) {
throw new TRPCError({
code: "BAD_REQUEST",
message: SchemaError.fromZod(_data.error, opts.input).message,
});
}
let rawPagerduty: unknown;
try {
rawPagerduty = JSON.parse(_data.data.pagerduty);
} catch {
throw new TRPCError({
code: "BAD_REQUEST",
message: "Invalid PagerDuty configuration: malformed JSON",
});
}
const parsed = PagerDutySchema.safeParse(rawPagerduty);
if (!parsed.success) {
throw new TRPCError({
code: "BAD_REQUEST",
message: "Invalid PagerDuty configuration",
});
}
if (parsed.data.integration_keys.length === 0) {
throw new TRPCError({
code: "BAD_REQUEST",
message: "No PagerDuty integration key provided",
});
}
await sendPagerDutyTest({
integrationKey: parsed.data.integration_keys[0].integration_key,
});
return;
}
throw new TRPCError({
code: "BAD_REQUEST",
message: "Invalid provider",
});
}),
createTelegramToken: protectedProcedure.query(async (opts) => {
const workspaceId = opts.ctx.workspace.id;
const randomId = nanoid(12);
const EXPIRY = 1800; // 30 minutes
try {
await redis.set(`telegram:workspace_token:${workspaceId}`, randomId, {
ex: EXPIRY,
});
return { token: randomId, redisAvailable: true };
} catch (error) {
// Redis unavailable (e.g., self-hosted without Redis)
// Return null token to signal frontend to use manual setup only
console.warn("Redis unavailable for Telegram token storage:", error);
return { token: null, redisAvailable: false };
}
}),
getTelegramUpdates: protectedProcedure
.input(
z
.object({
privateChatId: z.string().optional(),
since: z.number().optional(),
})
.optional(),
)
.query(async (opts) => {
const res = await fetch(
`https://api.telegram.org/bot${process.env.TELEGRAM_BOT_TOKEN}/getUpdates`,
);
const data = (await res.json()) as TelegramGetUpdatesResponse;
if (!data.ok || !data.result) return [];
const botUsername = process.env.NEXT_PUBLIC_TELEGRAM_BOT_USERNAME;
if (!botUsername) {
throw new TRPCError({
code: "INTERNAL_SERVER_ERROR",
message: "Telegram bot username not configured",
});
}
return processTelegramUpdates({
updates: data.result,
workspaceId: opts.ctx.workspace.id,
privateChatId: opts.input?.privateChatId,
since: opts.input?.since,
botUsername,
redisClient: redis,
});
}),
});