Open-source status page, incident response and uptime monitoring
TypeScript alertingincident-managementmcpmcp-servermonitoringmonitoring-as-codeobservabilityon-callopen-sourcesrestatus-pagestatuspagesynthetic-monitoringterraformtinybirdtursouptimeuptime-checkeruptime-monitor
import { and, db, eq, inArray } from "@openstatus/db";
import {
monitor,
page,
pageComponent,
pageComponentGroup,
workspace,
} from "@openstatus/db/src/schema";
import { afterAll, beforeAll, describe, expect, test } from "vitest";
import {
expectAuditRow,
createWorkspaceFixture,
makeApiKeyCtx,
makeUserCtx,
withTestTransaction,
} from "../../../test/helpers";
import type { DrizzleTx, ServiceContext } from "../../context";
import {
ConflictError,
ForbiddenError,
LimitExceededError,
NotFoundError,
} from "../../errors";
import { createPageComponent } from "../create";
import { deletePageComponent } from "../delete";
import { listPageComponents } from "../list";
import { updatePageComponent } from "../update";
import { updatePageComponentOrder } from "../update-order";
const TEST_PREFIX = "svc-page-component-test";
let teamCtx: ServiceContext;
let freeCtx: ServiceContext;
let testPageId: number;
let teamMonitorId: number;
let freeMonitorId: number;
beforeAll(async () => {
const team = (await createWorkspaceFixture("team")).workspace;
const free = (await createWorkspaceFixture("free")).workspace;
teamCtx = makeUserCtx(team, { userId: 1 });
freeCtx = makeUserCtx(free, { userId: 2 });
const pageRow = await db
.insert(page)
.values({
workspaceId: team.id,
title: `${TEST_PREFIX}-page`,
description: "test",
slug: `${TEST_PREFIX}-slug`,
customDomain: "",
})
.returning()
.get();
testPageId = pageRow.id;
const teamMonitor = await db
.insert(monitor)
.values({
workspaceId: team.id,
active: true,
url: "https://example.com",
name: `${TEST_PREFIX}-team-monitor`,
method: "GET",
periodicity: "10m",
regions: "ams",
})
.returning()
.get();
teamMonitorId = teamMonitor.id;
const freeMonitor = await db
.insert(monitor)
.values({
workspaceId: free.id,
active: true,
url: "https://example.com",
name: `${TEST_PREFIX}-free-monitor`,
method: "GET",
periodicity: "10m",
regions: "ams",
})
.returning()
.get();
freeMonitorId = freeMonitor.id;
});
afterAll(async () => {
await db
.delete(pageComponent)
.where(eq(pageComponent.pageId, testPageId))
.catch(() => undefined);
await db
.delete(pageComponentGroup)
.where(eq(pageComponentGroup.pageId, testPageId))
.catch(() => undefined);
await db
.delete(monitor)
.where(inArray(monitor.id, [teamMonitorId, freeMonitorId]))
.catch(() => undefined);
await db
.delete(page)
.where(eq(page.id, testPageId))
.catch(() => undefined);
});
describe("updatePageComponentOrder", () => {
test("creates monitor + static components and a group", async () => {
await withTestTransaction(async (tx) => {
const ctx = { ...teamCtx, db: tx };
await updatePageComponentOrder({
ctx,
input: {
pageId: testPageId,
components: [
{
order: 0,
name: `${TEST_PREFIX}-monitor-cmp`,
type: "monitor",
monitorId: teamMonitorId,
},
{
order: 1,
name: `${TEST_PREFIX}-static-cmp`,
type: "static",
},
],
groups: [
{
order: 2,
name: `${TEST_PREFIX}-group`,
defaultOpen: false,
components: [
{
order: 0,
name: `${TEST_PREFIX}-grouped-static`,
type: "static",
},
],
},
],
},
});
const components = await tx
.select()
.from(pageComponent)
.where(eq(pageComponent.pageId, testPageId))
.all();
const groups = await tx
.select()
.from(pageComponentGroup)
.where(eq(pageComponentGroup.pageId, testPageId))
.all();
expect(components).toHaveLength(3);
expect(groups).toHaveLength(1);
// Per-entity audit emits — assert one representative of each kind.
// The service writes one row per component / group, so every id in
// `components` + `groups` should appear, not a single page-level row.
const monitorComponent = components.find((c) => c.type === "monitor");
expect(monitorComponent).toBeDefined();
if (!monitorComponent) throw new Error("unreachable");
await expectAuditRow({
workspaceId: teamCtx.workspace.id,
action: "page_component.create",
entityType: "page_component",
entityId: monitorComponent.id,
db: tx,
});
const group = groups[0];
expect(group).toBeDefined();
if (!group) throw new Error("unreachable");
await expectAuditRow({
workspaceId: teamCtx.workspace.id,
action: "page_component_group.create",
entityType: "page_component_group",
entityId: group.id,
db: tx,
});
});
});
test("rejects cross-workspace monitorId with ForbiddenError", async () => {
await withTestTransaction(async (tx) => {
await expect(
updatePageComponentOrder({
ctx: { ...teamCtx, db: tx },
input: {
pageId: testPageId,
components: [
{
order: 0,
name: `${TEST_PREFIX}-cross-ws`,
type: "monitor",
monitorId: freeMonitorId,
},
],
groups: [],
},
}),
).rejects.toBeInstanceOf(ForbiddenError);
});
});
test("rejects cross-workspace pageId with ForbiddenError", async () => {
await withTestTransaction(async (tx) => {
await expect(
updatePageComponentOrder({
ctx: { ...freeCtx, db: tx },
input: {
pageId: testPageId, // team's page
components: [],
groups: [],
},
}),
).rejects.toBeInstanceOf(ForbiddenError);
});
});
test("upserts monitor components without creating duplicates", async () => {
await withTestTransaction(async (tx) => {
const ctx = { ...teamCtx, db: tx };
// The `(pageId, monitorId)` unique constraint + `onConflictDoUpdate`
// is the riskiest path in this service: a regression here would
// silently insert duplicate rows on every re-invocation. Run the
// service twice with the same `monitorId` — expect exactly one
// row, with the second call's values winning the update.
await updatePageComponentOrder({
ctx,
input: {
pageId: testPageId,
components: [
{
order: 0,
name: `${TEST_PREFIX}-upsert-initial`,
type: "monitor",
monitorId: teamMonitorId,
},
],
groups: [],
},
});
await updatePageComponentOrder({
ctx,
input: {
pageId: testPageId,
components: [
{
order: 5,
name: `${TEST_PREFIX}-upsert-renamed`,
type: "monitor",
monitorId: teamMonitorId,
},
],
groups: [],
},
});
const rows = await tx
.select()
.from(pageComponent)
.where(
and(
eq(pageComponent.pageId, testPageId),
eq(pageComponent.type, "monitor"),
eq(pageComponent.monitorId, teamMonitorId),
),
)
.all();
expect(rows).toHaveLength(1);
expect(rows[0]?.name).toBe(`${TEST_PREFIX}-upsert-renamed`);
expect(rows[0]?.order).toBe(5);
});
});
});
describe("listPageComponents", () => {
test("respects workspace isolation", async () => {
await withTestTransaction(async (tx) => {
const teamCtxTx = { ...teamCtx, db: tx };
const freeCtxTx = { ...freeCtx, db: tx };
// Seed at least one component on the team's page so the team-side
// listing has something to return.
await updatePageComponentOrder({
ctx: teamCtxTx,
input: {
pageId: testPageId,
components: [
{
order: 0,
name: `${TEST_PREFIX}-list-cmp`,
type: "static",
},
],
groups: [],
},
});
const teamResult = await listPageComponents({
ctx: teamCtxTx,
input: { pageId: testPageId, order: "asc" },
});
expect(teamResult.length).toBeGreaterThan(0);
const freeResult = await listPageComponents({
ctx: freeCtxTx,
input: { pageId: testPageId, order: "asc" },
});
expect(freeResult).toHaveLength(0);
});
});
});
describe("deletePageComponent", () => {
test("rejects read-only actor", async () => {
await withTestTransaction(async (tx) => {
const readOnlyCtx = {
...makeApiKeyCtx(teamCtx.workspace, {
keyId: "k-read",
userId: 1,
scopes: ["read"],
}),
db: tx,
};
await expect(
deletePageComponent({
ctx: readOnlyCtx,
input: { id: 999_999_999 },
}),
).rejects.toBeInstanceOf(ForbiddenError);
});
});
test("throws NotFoundError for cross-workspace id", async () => {
await withTestTransaction(async (tx) => {
const teamCtxTx = { ...teamCtx, db: tx };
// Seed a component on the team page so the cross-workspace delete
// has a real target id rather than asserting against an empty page.
await updatePageComponentOrder({
ctx: teamCtxTx,
input: {
pageId: testPageId,
components: [
{
order: 0,
name: `${TEST_PREFIX}-delete-target`,
type: "static",
},
],
groups: [],
},
});
const [anyComponent] = await tx
.select()
.from(pageComponent)
.where(eq(pageComponent.pageId, testPageId))
.all();
if (!anyComponent) {
throw new Error("test setup broken: no components present");
}
await expect(
deletePageComponent({
ctx: { ...freeCtx, db: tx },
input: { id: anyComponent.id },
}),
).rejects.toBeInstanceOf(NotFoundError);
});
});
});
describe("createPageComponent", () => {
test("rejects read-only actor", async () => {
await withTestTransaction(async (tx) => {
const readOnlyCtx = {
...makeApiKeyCtx(teamCtx.workspace, {
keyId: "k-read",
userId: 1,
scopes: ["read"],
}),
db: tx,
};
await expect(
createPageComponent({
ctx: readOnlyCtx,
input: {
pageId: testPageId,
type: "static",
name: `${TEST_PREFIX}-denied`,
order: 0,
},
}),
).rejects.toBeInstanceOf(ForbiddenError);
});
});
test("creates a static component and emits an audit row", async () => {
await withTestTransaction(async (tx) => {
const created = await createPageComponent({
ctx: { ...teamCtx, db: tx },
input: {
pageId: testPageId,
type: "static",
name: `${TEST_PREFIX}-static`,
description: "hello",
order: 3,
},
});
expect(created.type).toBe("static");
expect(created.monitorId).toBe(null);
expect(created.name).toBe(`${TEST_PREFIX}-static`);
await expectAuditRow({
workspaceId: teamCtx.workspace.id,
action: "page_component.create",
entityType: "page_component",
entityId: created.id,
db: tx,
});
});
});
test("inherits the monitor name when none is supplied", async () => {
await withTestTransaction(async (tx) => {
const created = await createPageComponent({
ctx: { ...teamCtx, db: tx },
input: {
pageId: testPageId,
type: "monitor",
monitorId: teamMonitorId,
order: 0,
},
});
expect(created.name).toBe(`${TEST_PREFIX}-team-monitor`);
});
});
test("rejects a monitor from another workspace", async () => {
await withTestTransaction(async (tx) => {
await expect(
createPageComponent({
ctx: { ...teamCtx, db: tx },
input: {
pageId: testPageId,
type: "monitor",
monitorId: freeMonitorId,
order: 0,
},
}),
).rejects.toBeInstanceOf(ForbiddenError);
});
});
test("rejects a page from another workspace", async () => {
await withTestTransaction(async (tx) => {
await expect(
createPageComponent({
ctx: { ...freeCtx, db: tx },
input: {
pageId: testPageId,
type: "static",
name: `${TEST_PREFIX}-cross`,
order: 0,
},
}),
).rejects.toBeInstanceOf(ForbiddenError);
});
});
test("rejects a monitor already attached to the page", async () => {
await withTestTransaction(async (tx) => {
const ctx = { ...teamCtx, db: tx };
const input = {
pageId: testPageId,
type: "monitor" as const,
monitorId: teamMonitorId,
order: 0,
};
await createPageComponent({ ctx, input });
await expect(createPageComponent({ ctx, input })).rejects.toBeInstanceOf(
ConflictError,
);
});
});
test("enforces the workspace-wide page-components limit", async () => {
await withTestTransaction(async (tx) => {
// The cap counts every page in the workspace, so seed the quota on a
// second page and prove the create on `testPageId` still trips it.
const otherPage = await tx
.insert(page)
.values({
workspaceId: teamCtx.workspace.id,
title: `${TEST_PREFIX}-limit-page`,
description: "test",
slug: `${TEST_PREFIX}-limit-slug`,
customDomain: "",
})
.returning()
.get();
// `assertWithinLimit` re-reads the workspace row, so the override has
// to land in the DB rather than only on the in-memory ctx.
await tx
.update(workspace)
.set({ limits: JSON.stringify({ "page-components": 1 }) })
.where(eq(workspace.id, teamCtx.workspace.id));
const ctx = { ...teamCtx, db: tx };
await createPageComponent({
ctx,
input: {
pageId: otherPage.id,
type: "static",
name: `${TEST_PREFIX}-limit-1`,
order: 0,
},
});
await expect(
createPageComponent({
ctx,
input: {
pageId: testPageId,
type: "static",
name: `${TEST_PREFIX}-limit-2`,
order: 0,
},
}),
).rejects.toBeInstanceOf(LimitExceededError);
});
});
test("at quota, a bad request still reports what's actually wrong", async () => {
await withTestTransaction(async (tx) => {
const ctx = { ...teamCtx, db: tx };
const input = {
pageId: testPageId,
type: "monitor" as const,
monitorId: teamMonitorId,
order: 0,
};
await createPageComponent({ ctx, input });
// Quota is now spent, but neither of these would consume a slot —
// "limit reached" would send the caller chasing the wrong problem.
await tx
.update(workspace)
.set({ limits: JSON.stringify({ "page-components": 1 }) })
.where(eq(workspace.id, teamCtx.workspace.id));
await expect(createPageComponent({ ctx, input })).rejects.toBeInstanceOf(
ConflictError,
);
await expect(
createPageComponent({
ctx,
input: { ...input, monitorId: freeMonitorId },
}),
).rejects.toBeInstanceOf(ForbiddenError);
});
});
});
describe("updatePageComponent", () => {
test("rejects read-only actor", async () => {
await withTestTransaction(async (tx) => {
const readOnlyCtx = {
...makeApiKeyCtx(teamCtx.workspace, {
keyId: "k-read",
userId: 1,
scopes: ["read"],
}),
db: tx,
};
await expect(
updatePageComponent({
ctx: readOnlyCtx,
input: { id: 999_999_999, name: "nope" },
}),
).rejects.toBeInstanceOf(ForbiddenError);
});
});
test("patches only the supplied fields and emits an audit row", async () => {
await withTestTransaction(async (tx) => {
const teamCtxTx = { ...teamCtx, db: tx };
const created = await createPageComponent({
ctx: teamCtxTx,
input: {
pageId: testPageId,
type: "static",
name: `${TEST_PREFIX}-before`,
description: "keep me",
order: 1,
},
});
const updated = await updatePageComponent({
ctx: teamCtxTx,
input: { id: created.id, name: `${TEST_PREFIX}-after` },
});
expect(updated.name).toBe(`${TEST_PREFIX}-after`);
expect(updated.description).toBe("keep me");
expect(updated.order).toBe(1);
await expectAuditRow({
workspaceId: teamCtx.workspace.id,
action: "page_component.update",
entityType: "page_component",
entityId: created.id,
db: tx,
});
});
});
test("throws NotFoundError for cross-workspace id", async () => {
await withTestTransaction(async (tx) => {
const created = await createPageComponent({
ctx: { ...teamCtx, db: tx },
input: {
pageId: testPageId,
type: "static",
name: `${TEST_PREFIX}-cross-update`,
order: 0,
},
});
await expect(
updatePageComponent({
ctx: { ...freeCtx, db: tx },
input: { id: created.id, name: "nope" },
}),
).rejects.toBeInstanceOf(NotFoundError);
});
});
});
describe("page component group scoping", () => {
async function makeGroup(tx: DrizzleTx, pageId: number, name: string) {
return tx
.insert(pageComponentGroup)
.values({ workspaceId: teamCtx.workspace.id, pageId, name })
.returning()
.get();
}
async function makeSecondPage(tx: DrizzleTx) {
return tx
.insert(page)
.values({
workspaceId: teamCtx.workspace.id,
title: `${TEST_PREFIX}-page-2`,
description: "test",
slug: `${TEST_PREFIX}-slug-2`,
customDomain: "",
})
.returning()
.get();
}
test("createPageComponent accepts a group on the same page", async () => {
await withTestTransaction(async (tx) => {
const group = await makeGroup(tx, testPageId, `${TEST_PREFIX}-grp-ok`);
const created = await createPageComponent({
ctx: { ...teamCtx, db: tx },
input: {
pageId: testPageId,
type: "static",
name: `${TEST_PREFIX}-grouped`,
order: 0,
groupId: group.id,
},
});
expect(created.groupId).toBe(group.id);
});
});
test("createPageComponent rejects a group from a sibling page", async () => {
await withTestTransaction(async (tx) => {
// Workspace scope alone isn't enough — a sibling page's group would
// render the component under a group it isn't on.
const otherPage = await makeSecondPage(tx);
const foreignGroup = await makeGroup(
tx,
otherPage.id,
`${TEST_PREFIX}-grp-foreign`,
);
await expect(
createPageComponent({
ctx: { ...teamCtx, db: tx },
input: {
pageId: testPageId,
type: "static",
name: `${TEST_PREFIX}-bad-group`,
order: 0,
groupId: foreignGroup.id,
},
}),
).rejects.toBeInstanceOf(NotFoundError);
});
});
test("updatePageComponent rejects a group from a sibling page", async () => {
await withTestTransaction(async (tx) => {
const teamCtxTx = { ...teamCtx, db: tx };
const otherPage = await makeSecondPage(tx);
const foreignGroup = await makeGroup(
tx,
otherPage.id,
`${TEST_PREFIX}-grp-foreign-2`,
);
const created = await createPageComponent({
ctx: teamCtxTx,
input: {
pageId: testPageId,
type: "static",
name: `${TEST_PREFIX}-regroup`,
order: 0,
},
});
await expect(
updatePageComponent({
ctx: teamCtxTx,
input: { id: created.id, groupId: foreignGroup.id },
}),
).rejects.toBeInstanceOf(NotFoundError);
});
});
test("updatePageComponent clears the group with null", async () => {
await withTestTransaction(async (tx) => {
const teamCtxTx = { ...teamCtx, db: tx };
const group = await makeGroup(tx, testPageId, `${TEST_PREFIX}-grp-clear`);
const created = await createPageComponent({
ctx: teamCtxTx,
input: {
pageId: testPageId,
type: "static",
name: `${TEST_PREFIX}-ungroup`,
order: 0,
groupId: group.id,
},
});
expect(created.groupId).toBe(group.id);
const updated = await updatePageComponent({
ctx: teamCtxTx,
input: { id: created.id, groupId: null },
});
expect(updated.groupId).toBe(null);
});
});
});