Skip to content

Open-source status page, incident response and uptime monitoring

feat: page-components status-page feed (#1784)

Maximilian Kaske1871de924d92
diff --git a/apps/docs/src/content/docs/reference/status-page.mdx b/apps/docs/src/content/docs/reference/status-page.mdx
index cf598a51f..9695f9081 100644
--- a/apps/docs/src/content/docs/reference/status-page.mdx
+++ b/apps/docs/src/content/docs/reference/status-page.mdx
@@ -60,6 +60,16 @@ Provides a machine-readable JSON representation of your status page data. This f
**Example:** `https://status.openstatus.dev/feed/json`
+**Deprecation Notice:**
+
+The following fields are deprecated and will be removed in a future version:
+
+- **`monitors`** (top-level): Use `pageComponents` instead, which provides a more flexible component-based structure that supports both monitors and external services.
+- **`maintenances[].monitors`**: Use `maintenances[].pageComponents` instead, which references page component IDs rather than monitor IDs.
+- **`statusReports[].monitors`**: Use `statusReports[].pageComponents` instead, which references page component IDs rather than monitor IDs.
+
+These deprecated fields are currently maintained for backward compatibility but may be removed in future versions.
+
### SSH Command
**Type:** Command-line utility
diff --git a/apps/status-page/src/app/(status-page)/[domain]/(public)/feed/[type]/route.ts b/apps/status-page/src/app/(status-page)/[domain]/(public)/feed/[type]/route.ts
index be2bc2336..ce43a7a84 100644
--- a/apps/status-page/src/app/(status-page)/[domain]/(public)/feed/[type]/route.ts
+++ b/apps/status-page/src/app/(status-page)/[domain]/(public)/feed/[type]/route.ts
@@ -24,27 +24,32 @@ export async function GET(
if (!["rss", "atom"].includes(type)) return notFound();
- const page = await queryClient.fetchQuery(
+ const _page = await queryClient.fetchQuery(
trpc.page.getPageBySlug.queryOptions({ slug: domain }),
);
- if (!page) return notFound();
+ if (!_page) return notFound();
- if (page.accessType === "password") {
+ if (_page.accessType === "password") {
const url = new URL(_request.url);
const password = url.searchParams.get("pw");
- console.log({ url, page, password });
- if (password !== page.password) return unauthorized();
+ console.log({ url, _page, password });
+ if (password !== _page.password) return unauthorized();
}
- if (page.accessType === "email-domain") {
+ if (_page.accessType === "email-domain") {
const session = await auth();
const user = session?.user;
- const allowedDomains = page.authEmailDomains ?? [];
+ const allowedDomains = _page.authEmailDomains ?? [];
if (!user || !user.email) return unauthorized();
if (!allowedDomains.includes(user.email.split("@")[1]))
return unauthorized();
}
+ const page = await queryClient.fetchQuery(
+ trpc.statusPage.get.queryOptions({ slug: domain }),
+ );
+ if (!page) return notFound();
+
const baseUrl = getBaseUrl({
slug: page.slug,
customDomain: page.customDomain,
diff --git a/apps/status-page/src/app/(status-page)/[domain]/(public)/feed/json/route.ts b/apps/status-page/src/app/(status-page)/[domain]/(public)/feed/json/route.ts
index d8f6aaea2..4d05b2b30 100644
--- a/apps/status-page/src/app/(status-page)/[domain]/(public)/feed/json/route.ts
+++ b/apps/status-page/src/app/(status-page)/[domain]/(public)/feed/json/route.ts
@@ -2,14 +2,6 @@ import { auth } from "@/lib/auth";
import { getQueryClient, trpc } from "@/lib/trpc/server";
import { notFound, unauthorized } from "next/navigation";
-const _STATUS_LABELS = {
- investigating: "Investigating",
- identified: "Identified",
- monitoring: "Monitoring",
- resolved: "Resolved",
- maintenance: "Maintenance",
-} as const;
-
export const revalidate = 60;
export async function GET(
@@ -53,12 +45,27 @@ export async function GET(
description: page.description,
status: page.status,
updatedAt: new Date(),
+ // @deprecated Use pageComponents instead
monitors: page.monitors.map((monitor) => ({
id: monitor.id,
name: monitor.name,
description: monitor.description,
status: monitor.status,
})),
+ // New field - exposes the page component structure
+ pageComponents: page.pageComponents.map((component) => ({
+ id: component.id,
+ name: component.name,
+ description: component.description,
+ monitorId: component.monitorId,
+ order: component.order,
+ groupId: component.groupId,
+ groupOrder: component.groupOrder,
+ })),
+ pageComponentGroups: page.pageComponentGroups.map((group) => ({
+ id: group.id,
+ name: group.name,
+ })),
maintenances: page.maintenances.map((maintenance) => ({
id: maintenance.id,
name: maintenance.title,
@@ -66,16 +73,26 @@ export async function GET(
from: maintenance.from,
to: maintenance.to,
updatedAt: maintenance.updatedAt,
+ // @deprecated Use components instead
monitors: maintenance.maintenancesToMonitors.map(
(item) => item.monitor.id,
),
+ // New field - references page component IDs
+ pageComponents: maintenance.maintenancesToPageComponents.map(
+ (item) => item.pageComponentId,
+ ),
})),
statusReports: page.statusReports.map((report) => ({
id: report.id,
title: report.title,
- updateAt: report.updatedAt,
+ updatedAt: report.updatedAt,
status: report.status,
+ // @deprecated Use components instead
monitors: report.monitorsToStatusReports.map((item) => item.monitor.id),
+ // New field - references page component IDs
+ pageComponents: report.statusReportsToPageComponents.map(
+ (item) => item.pageComponentId,
+ ),
statusReportUpdates: report.statusReportUpdates.map((update) => ({
id: update.id,
status: update.status,
diff --git a/packages/api/src/router/statusPage.e2e.test.ts b/packages/api/src/router/statusPage.e2e.test.ts
index 54647f87a..efd38857d 100644
--- a/packages/api/src/router/statusPage.e2e.test.ts
+++ b/packages/api/src/router/statusPage.e2e.test.ts
@@ -576,6 +576,10 @@ describe("Re-subscription after unsubscribe flow", () => {
where: eq(pageSubscriber.email, "[email protected]"),
});
+ if (!subscriber) {
+ throw new Error("Subscriber ID is undefined");
+ }
+
expect(subscriber?.acceptedAt).not.toBeNull();
expect(subscriber?.unsubscribedAt).toBeNull();
@@ -583,10 +587,10 @@ describe("Re-subscription after unsubscribe flow", () => {
await db
.update(pageSubscriber)
.set({ unsubscribedAt: new Date() })
- .where(eq(pageSubscriber.id, subscriber?.id));
+ .where(eq(pageSubscriber.id, subscriber.id));
subscriber = await db.query.pageSubscriber.findFirst({
- where: eq(pageSubscriber.id, subscriber?.id),
+ where: eq(pageSubscriber.id, subscriber.id),
});
expect(subscriber?.unsubscribedAt).not.toBeNull();
@@ -607,6 +611,10 @@ describe("Re-subscription after unsubscribe flow", () => {
expect(subscribersAfterUnsub.length).toBe(0);
+ if (!subscriber) {
+ throw new Error("Subscriber is undefined");
+ }
+
// Step 4: User re-subscribes (simulating the re-subscription flow)
const newToken = crypto.randomUUID();
await db
@@ -617,7 +625,7 @@ describe("Re-subscription after unsubscribe flow", () => {
token: newToken,
expiresAt: new Date(Date.now() + 1000 * 60 * 60 * 24 * 7),
})
- .where(eq(pageSubscriber.id, subscriber?.id));
+ .where(eq(pageSubscriber.id, subscriber.id));
// Step 5: User is still excluded (not yet verified)
const subscribersPendingVerify = await db
@@ -720,3 +728,194 @@ describe("Invalid token handling", () => {
.where(eq(pageSubscriber.email, "[email protected]"));
});
});
+
+describe("statusPage.get endpoint validation", () => {
+ test("Returns all required output fields with correct types", async () => {
+ // Use the edgeRouter to call the statusPage.get endpoint
+ const { edgeRouter } = await import("../edge");
+ const { createInnerTRPCContext } = await import("../trpc");
+
+ const ctx = createInnerTRPCContext({
+ req: undefined,
+ // @ts-expect-error - auth not required for public procedure
+ auth: undefined,
+ });
+
+ const caller = edgeRouter.createCaller(ctx);
+ const result = await caller.statusPage.get({ slug: testSlug });
+
+ // Validate that result is not null
+ expect(result).toBeDefined();
+ expect(result).not.toBeNull();
+
+ if (!result) {
+ throw new Error("Result should not be null");
+ }
+
+ // Validate core page fields with specific types
+ expect(typeof result.slug).toBe("string");
+ expect(typeof result.title).toBe("string");
+ expect(typeof result.description).toBe("string");
+ expect(result.createdAt).toBeInstanceOf(Date);
+ expect(result.updatedAt).toBeInstanceOf(Date);
+
+ // Validate slug matches what we requested
+ expect(result.slug).toBe(testSlug);
+
+ // Validate all array fields exist and are arrays
+ expect(Array.isArray(result.monitors)).toBe(true);
+ expect(Array.isArray(result.monitorGroups)).toBe(true);
+ expect(Array.isArray(result.pageComponents)).toBe(true);
+ expect(Array.isArray(result.pageComponentGroups)).toBe(true);
+ expect(Array.isArray(result.trackers)).toBe(true);
+ expect(Array.isArray(result.lastEvents)).toBe(true);
+ expect(Array.isArray(result.openEvents)).toBe(true);
+ expect(Array.isArray(result.statusReports)).toBe(true);
+ expect(Array.isArray(result.incidents)).toBe(true);
+ expect(Array.isArray(result.maintenances)).toBe(true);
+
+ // Validate status field is one of the allowed values
+ expect(["success", "degraded", "error", "info"]).toContain(result.status);
+
+ // Validate workspacePlan field
+ expect(result.workspacePlan).toBeDefined();
+ expect(typeof result.workspacePlan).toBe("string");
+
+ // Validate whiteLabel field
+ expect(typeof result.whiteLabel).toBe("boolean");
+ });
+
+ test("Returns null for non-existent slug", async () => {
+ const { edgeRouter } = await import("../edge");
+ const { createInnerTRPCContext } = await import("../trpc");
+
+ const ctx = createInnerTRPCContext({
+ req: undefined,
+ // @ts-expect-error - auth not required for public procedure
+ auth: undefined,
+ });
+
+ const caller = edgeRouter.createCaller(ctx);
+ const result = await caller.statusPage.get({
+ slug: "non-existent-slug-12345",
+ });
+
+ expect(result).toBeNull();
+ });
+
+ test("Tracker objects have correct discriminated union types", async () => {
+ const { edgeRouter } = await import("../edge");
+ const { createInnerTRPCContext } = await import("../trpc");
+
+ const ctx = createInnerTRPCContext({
+ req: undefined,
+ // @ts-expect-error - auth not required for public procedure
+ auth: undefined,
+ });
+
+ const caller = edgeRouter.createCaller(ctx);
+ const result = await caller.statusPage.get({ slug: testSlug });
+
+ if (!result) {
+ // If no result, skip this test as there are no trackers to validate
+ return;
+ }
+
+ // Validate each tracker has the correct structure
+ for (const tracker of result.trackers) {
+ expect(tracker).toHaveProperty("type");
+ expect(tracker).toHaveProperty("order");
+
+ if (tracker.type === "monitor") {
+ expect(tracker).toHaveProperty("monitor");
+ expect(tracker.monitor).toHaveProperty("id");
+ expect(tracker.monitor).toHaveProperty("name");
+ expect(tracker.monitor).toHaveProperty("status");
+ expect(["success", "degraded", "error", "info"]).toContain(
+ tracker.monitor.status,
+ );
+ } else if (tracker.type === "group") {
+ expect(tracker).toHaveProperty("groupId");
+ expect(tracker).toHaveProperty("groupName");
+ expect(tracker).toHaveProperty("monitors");
+ expect(tracker).toHaveProperty("status");
+ expect(Array.isArray(tracker.monitors)).toBe(true);
+ expect(["success", "degraded", "error", "info"]).toContain(
+ tracker.status,
+ );
+ }
+ }
+ });
+
+ test("Event objects have required fields", async () => {
+ const { edgeRouter } = await import("../edge");
+ const { createInnerTRPCContext } = await import("../trpc");
+
+ const ctx = createInnerTRPCContext({
+ req: undefined,
+ // @ts-expect-error - auth not required for public procedure
+ auth: undefined,
+ });
+
+ const caller = edgeRouter.createCaller(ctx);
+ const result = await caller.statusPage.get({ slug: testSlug });
+
+ if (!result) {
+ return;
+ }
+
+ // Validate lastEvents structure
+ for (const event of result.lastEvents) {
+ expect(event).toMatchObject({
+ id: expect.any(Number),
+ name: expect.any(String),
+ from: expect.any(Date),
+ status: expect.any(String),
+ type: expect.any(String),
+ });
+ expect(["maintenance", "incident", "report"]).toContain(event.type);
+ expect(["success", "degraded", "error", "info"]).toContain(event.status);
+ }
+
+ // Validate openEvents structure
+ for (const event of result.openEvents) {
+ expect(event).toMatchObject({
+ id: expect.any(Number),
+ name: expect.any(String),
+ from: expect.any(Date),
+ status: expect.any(String),
+ type: expect.any(String),
+ });
+ expect(["maintenance", "incident", "report"]).toContain(event.type);
+ expect(["success", "degraded", "error", "info"]).toContain(event.status);
+ }
+ });
+
+ test("Monitor objects contain status field", async () => {
+ const { edgeRouter } = await import("../edge");
+ const { createInnerTRPCContext } = await import("../trpc");
+
+ const ctx = createInnerTRPCContext({
+ req: undefined,
+ // @ts-expect-error - auth not required for public procedure
+ auth: undefined,
+ });
+
+ const caller = edgeRouter.createCaller(ctx);
+ const result = await caller.statusPage.get({ slug: testSlug });
+
+ if (!result || result.monitors.length === 0) {
+ return;
+ }
+
+ // Validate each monitor has status field
+ for (const monitor of result.monitors) {
+ expect(monitor).toHaveProperty("status");
+ expect(["success", "degraded", "error", "info"]).toContain(
+ monitor.status,
+ );
+ expect(monitor).toHaveProperty("id");
+ expect(monitor).toHaveProperty("name");
+ }
+ });
+});
diff --git a/packages/api/src/router/statusPage.ts b/packages/api/src/router/statusPage.ts
index 3f603b334..1d03aefc7 100644
--- a/packages/api/src/router/statusPage.ts
+++ b/packages/api/src/router/statusPage.ts
@@ -345,6 +345,8 @@ export const statusPageRouter = createTRPCRouter({
status,
lastEvents,
openEvents,
+ pageComponents,
+ pageComponentGroups: _page.pageComponentGroups,
whiteLabel,
});
}),
diff --git a/packages/db/src/schema/shared.ts b/packages/db/src/schema/shared.ts
index 6a588d48d..f55c305bf 100644
--- a/packages/db/src/schema/shared.ts
+++ b/packages/db/src/schema/shared.ts
@@ -32,6 +32,14 @@ export const selectPublicMonitorSchema =
export const selectStatusReportPageSchema = selectStatusReportSchema.extend({
statusReportUpdates: z.array(selectStatusReportUpdateSchema).prefault([]),
+ statusReportsToPageComponents: z
+ .array(
+ z.object({
+ pageComponentId: z.number(),
+ statusReportId: z.number(),
+ }),
+ )
+ .prefault([]),
monitorsToStatusReports: z
.array(
z.object({
@@ -44,6 +52,14 @@ export const selectStatusReportPageSchema = selectStatusReportSchema.extend({
});
export const selectMaintenancePageSchema = selectMaintenanceSchema.extend({
+ maintenancesToPageComponents: z
+ .array(
+ z.object({
+ pageComponentId: z.number(),
+ maintenanceId: z.number(),
+ }),
+ )
+ .prefault([]),
maintenancesToMonitors: z
.array(
z.object({
@@ -139,24 +155,6 @@ export const statusPageEventSchema = z.object({
type: z.enum(["maintenance", "incident", "report"]),
});
-export const selectPublicPageSchemaWithRelation = selectPageSchema.extend({
- monitorGroups: selectMonitorGroupSchema.array().prefault([]),
- // TODO: include status of the monitor
- monitors: selectPublicMonitorWithStatusSchema.array(),
- trackers: trackersSchema,
- lastEvents: z.array(statusPageEventSchema),
- openEvents: z.array(statusPageEventSchema),
- statusReports: z.array(selectStatusReportPageSchema),
- incidents: z.array(selectIncidentSchema),
- maintenances: z.array(selectMaintenancePageSchema),
- status: z.enum(["success", "degraded", "error", "info"]).prefault("success"),
- workspacePlan: workspacePlanSchema
- .nullable()
- .prefault("free")
- .transform((val) => val ?? "free"),
- whiteLabel: z.boolean().prefault(false),
-});
-
export const selectPageComponentWithMonitorRelation =
selectPageComponentSchema.extend({
monitor: selectPublicMonitorBaseSchema
@@ -175,6 +173,26 @@ export type PageComponentWithMonitorRelation = z.infer<
typeof selectPageComponentWithMonitorRelation
>;
+export const selectPublicPageSchemaWithRelation = selectPageSchema.extend({
+ monitorGroups: selectMonitorGroupSchema.array().prefault([]),
+ // TODO: include status of the monitor
+ monitors: selectPublicMonitorWithStatusSchema.array(),
+ pageComponents: selectPageComponentWithMonitorRelation.array().prefault([]),
+ pageComponentGroups: selectPageComponentGroupSchema.array().prefault([]),
+ trackers: trackersSchema,
+ lastEvents: z.array(statusPageEventSchema),
+ openEvents: z.array(statusPageEventSchema),
+ statusReports: z.array(selectStatusReportPageSchema),
+ incidents: z.array(selectIncidentSchema),
+ maintenances: z.array(selectMaintenancePageSchema),
+ status: z.enum(["success", "degraded", "error", "info"]).prefault("success"),
+ workspacePlan: workspacePlanSchema
+ .nullable()
+ .prefault("free")
+ .transform((val) => val ?? "free"),
+ whiteLabel: z.boolean().prefault(false),
+});
+
export const selectPublicStatusReportSchemaWithRelation =
selectStatusReportSchema.extend({
monitorsToStatusReports: z